Tests and verification

Author: 7vignesh

bun.lock

@@ -14,12 +14,14 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
   },
   "dependencies": {
     "@stackforge/shared": "workspace:*"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.11",
     "@types/node": "^22.13.10",
     "typescript": "^5.7.3"
   }

packages/agents/package.json

@@ -0,0 +1,71 @@
+/// <reference types="bun" />
+import { afterEach, describe, expect, it } from "bun:test";
+import { OpenRouterProvider } from "../src/provider/openrouter.provider.js";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("OpenRouterProvider", () => {
+  it("parses JSON response and exposes usage metrics", async () => {
+    globalThis.fetch = async () =>
+      new Response(
+        JSON.stringify({
+          choices: [{ message: { content: '{"projectName":"acme"}' } }],
+          usage: { prompt_tokens: 120, completion_tokens: 80, total_tokens: 200 },
+          model: "openai/gpt-4o-mini",
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+
+    const provider = new OpenRouterProvider({ apiKey: "test-key" });
+
+    const result = await provider.call({
+      agentName: "planner",
+      input: { prompt: "build app", projectName: "acme" },
+      options: {
+        systemPrompt: "Return JSON",
+        userPrompt: "{\"prompt\":\"build app\"}",
+        model: "openai/gpt-4o-mini",
+        maxInputTokens: 300,
+        maxOutputTokens: 300,
+        temperature: 0.1,
+      },
+    });
+
+    expect(result.output).toEqual({ projectName: "acme" });
+    expect(result.inputTokens).toBe(120);
+    expect(result.outputTokens).toBe(80);
+    expect(result.tokensUsed).toBe(200);
+    expect(result.model).toBe("openai/gpt-4o-mini");
+  });
+
+  it("throws on non-JSON model content", async () => {
+    globalThis.fetch = async () =>
+      new Response(
+        JSON.stringify({
+          choices: [{ message: { content: "not-json" } }],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+
+    const provider = new OpenRouterProvider({ apiKey: "test-key" });
+
+    await expect(
+      provider.call({
+        agentName: "planner",
+        input: { prompt: "build app", projectName: "acme" },
+        options: {
+          systemPrompt: "Return JSON",
+          userPrompt: "{}",
+          model: "openai/gpt-4o-mini",
+          maxInputTokens: 300,
+          maxOutputTokens: 300,
+          temperature: 0.1,
+        },
+      }),
+    ).rejects.toThrow("OpenRouter returned non-JSON content");
+  });
+});

packages/agents/test/openrouter-provider.test.ts

@@ -0,0 +1,60 @@
+/// <reference types="bun" />
+import { describe, expect, it } from "bun:test";
+import type { ProviderCallInput, ProviderCallOutput } from "../src/provider/provider.interface.js";
+import type { LLMProvider } from "../src/provider/provider.interface.js";
+import { runOrchestrator } from "../src/orchestrator/orchestrator.service.js";
+import { AgentCache } from "../src/cache/agent.cache.js";
+import type { SSEEvent } from "@stackforge/shared";
+
+class InvalidPlannerProvider implements LLMProvider {
+  readonly name = "invalid-planner";
+
+  async call({ agentName }: ProviderCallInput): Promise<ProviderCallOutput> {
+    if (agentName === "planner") {
+      return {
+        output: { bad: true },
+        tokensUsed: 42,
+        durationMs: 5,
+        inputTokens: 20,
+        outputTokens: 22,
+        model: "test-model",
+      };
+    }
+
+    return {
+      output: {},
+      tokensUsed: 1,
+      durationMs: 1,
+      inputTokens: 1,
+      outputTokens: 0,
+      model: "test-model",
+    };
+  }
+}
+
+describe("Orchestrator failure propagation", () => {
+  it("emits agent_failed and rejects when agent output schema validation fails", async () => {
+    const events: SSEEvent[] = [];
+    const provider = new InvalidPlannerProvider();
+
+    await expect(
+      runOrchestrator({
+        jobId: crypto.randomUUID(),
+        prompt: "Build a task management platform",
+        projectName: "taskflow",
+        emit: (event) => events.push(event),
+        provider,
+        cache: new AgentCache(),
+      }),
+    ).rejects.toBeDefined();
+
+    const started = events.find((event) => event.type === "agent_started" && event.agent === "planner");
+    const failed = events.find((event) => event.type === "agent_failed" && event.agent === "planner");
+
+    expect(started).toBeDefined();
+    expect(failed).toBeDefined();
+    if (failed?.type === "agent_failed") {
+      expect(failed.payload.error.length).toBeGreaterThan(0);
+    }
+  });
+});

packages/agents/test/orchestrator-failure.test.ts

@@ -0,0 +1,37 @@
+/// <reference types="bun" />
+import { describe, it, expect } from "bun:test";
+import { optimizeAgentPayload } from "../src/optimizer/token.optimizer.js";
+import { AGENT_CONFIGS } from "../src/config/agent.configs.js";
+
+describe("Token optimizer", () => {
+  it("compresses oversized prompt input within configured input token limit", () => {
+    const veryLongPrompt = "Build enterprise app. ".repeat(3000);
+
+    const result = optimizeAgentPayload("planner", {
+      prompt: veryLongPrompt,
+      projectName: "planner-test",
+    });
+
+    expect(result.maxInputTokens).toBe(900);
+    expect(result.estimatedInputTokens).toBeLessThanOrEqual(result.maxInputTokens);
+    expect(result.compressionPasses).toBeGreaterThanOrEqual(1);
+    expect(result.userPrompt.length).toBeLessThanOrEqual(result.maxInputTokens * 4);
+  });
+
+  it("fails fast when remaining budget cannot satisfy minimum output tokens", () => {
+    const original = AGENT_CONFIGS.devops.minOutputTokens;
+    AGENT_CONFIGS.devops.minOutputTokens = AGENT_CONFIGS.devops.tokenBudget;
+
+    try {
+      expect(() =>
+        optimizeAgentPayload("devops", {
+          prompt: "x".repeat(40000),
+          stack: { backend: "express", database: "postgres" },
+          entities: Array.from({ length: 200 }, (_, index) => ({ name: `Entity${index}` })),
+        }),
+      ).toThrow("Insufficient output token budget");
+    } finally {
+      AGENT_CONFIGS.devops.minOutputTokens = original;
+    }
+  });
+});