@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/providers/__tests__/base.test.ts

@@ -3,7 +3,9 @@ import {
   createProviderError,
   DEFAULT_REQUEST_TIMEOUT_MS,
   ensureJsonResponseFormat,
+  extractResponseSchema,
   extractMessages,
+  isJsonResponseFormat,
   isRetryableError,
   sleep,
   stripMarkdownFences,
@@ -305,6 +307,66 @@ describe("ensureJsonResponseFormat", () => {
   });
 });
 
+describe("isJsonResponseFormat", () => {
+  it('returns true for "json"', () => {
+    expect(isJsonResponseFormat("json")).toBe(true);
+  });
+
+  it('returns true for "json_object"', () => {
+    expect(isJsonResponseFormat("json_object")).toBe(true);
+  });
+
+  it('returns true for { type: "json_object" }', () => {
+    expect(isJsonResponseFormat({ type: "json_object" })).toBe(true);
+  });
+
+  it("returns true for { json_schema: {} }", () => {
+    expect(isJsonResponseFormat({ json_schema: {} })).toBe(true);
+  });
+
+  it("returns false for undefined", () => {
+    expect(isJsonResponseFormat(undefined)).toBe(false);
+  });
+
+  it("returns false for null", () => {
+    expect(isJsonResponseFormat(null)).toBe(false);
+  });
+
+  it('returns false for ""', () => {
+    expect(isJsonResponseFormat("")).toBe(false);
+  });
+
+  it('returns false for "text"', () => {
+    expect(isJsonResponseFormat("text")).toBe(false);
+  });
+
+  it("returns false for an object with neither json_object type nor json_schema", () => {
+    expect(isJsonResponseFormat({ type: "text" })).toBe(false);
+    expect(isJsonResponseFormat({ foo: "bar" })).toBe(false);
+  });
+});
+
+describe("extractResponseSchema", () => {
+  it("returns the schema when json_schema is present", () => {
+    const schema = { type: "object", properties: { name: { type: "string" } } };
+    expect(extractResponseSchema({ json_schema: schema })).toBe(schema);
+  });
+
+  it("returns undefined for a plain string responseFormat", () => {
+    expect(extractResponseSchema("json")).toBeUndefined();
+    expect(extractResponseSchema("json_object")).toBeUndefined();
+  });
+
+  it("returns undefined when json_schema is absent", () => {
+    expect(extractResponseSchema({ type: "json_object" })).toBeUndefined();
+  });
+
+  it("returns undefined for undefined/null", () => {
+    expect(extractResponseSchema(undefined)).toBeUndefined();
+    expect(extractResponseSchema(null)).toBeUndefined();
+  });
+});
+
 describe("createProviderError", () => {
   it("returns an Error with status, code, and details", () => {
     const err = createProviderError(500, { message: "server error" }, "fallback");

package/src/providers/__tests__/claude-code.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { ProviderJsonModeError, ProviderJsonParseError } from "../types.ts";
+import { ProviderJsonParseError } from "../types.ts";
 import type { ClaudeCodeOptions } from "../types.ts";
 
 const baseOptions: ClaudeCodeOptions = {
@@ -86,18 +86,15 @@ describe("claudeCodeChat", () => {
     expect(result.content).toEqual(jsonPayload);
   });
 
-  it("reports usage as zeros", async () => {
+  it("does not report usage on success", async () => {
     spawnMock.mockReturnValue(
       createMockProcFromText(JSON.stringify({ ok: true })),
     );
 
     const result = await claudeCodeChat(baseOptions);
 
-    expect(result.usage).toEqual({
-      prompt_tokens: 0,
-      completion_tokens: 0,
-      total_tokens: 0,
-    });
+    expect(result.usage).toBeUndefined();
+    expect(result.usageAvailable).toBeUndefined();
   });
 
   it("uses custom model and maxTurns when provided", async () => {
@@ -143,6 +140,7 @@ describe("claudeCodeChat", () => {
         { role: "system", content: "Be concise." },
         { role: "user", content: "Hello" },
       ],
+      responseFormat: "json",
     });
 
     const callArgs = spawnMock.mock.calls[0]![0] as string[];
@@ -166,13 +164,17 @@ describe("claudeCodeChat", () => {
     expect(callArgs[callArgs.indexOf("--max-tokens") + 1]).toBe("2048");
   });
 
-  it("throws ProviderJsonModeError when responseFormat is invalid", async () => {
-    await expect(
-      claudeCodeChat({
-        ...baseOptions,
-        responseFormat: "text",
-      }),
-    ).rejects.toBeInstanceOf(ProviderJsonModeError);
+  it("returns plain text content when responseFormat is omitted (AC-13)", async () => {
+    spawnMock.mockReturnValue(
+      createMockProcFromText("not json, just text"),
+    );
+
+    const result = await claudeCodeChat({
+      messages: [{ role: "user", content: "Give me json." }],
+    });
+
+    expect(typeof result.content).toBe("string");
+    expect(result.content).toBe("not json, just text");
   });
 
   describe("streaming accumulation", () => {
@@ -200,6 +202,89 @@ describe("claudeCodeChat", () => {
       expect(result.content).toEqual({ ok: true });
     });
   });
+
+  describe("requestTimeoutMs (AC-12)", () => {
+    let realClearTimeout: typeof globalThis.clearTimeout;
+    let realSetTimeout: typeof globalThis.setTimeout;
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+      realClearTimeout = globalThis.clearTimeout;
+      realSetTimeout = globalThis.setTimeout;
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      globalThis.clearTimeout = realClearTimeout;
+      globalThis.setTimeout = realSetTimeout;
+    });
+
+    it("applies requestTimeoutMs to the subprocess idle abort", async () => {
+      const TIMEOUT_MS = 1_000;
+      const killFn = vi.fn();
+      let resolveExit: (code: number | null) => void = () => {};
+      const mockExit = new Promise<number | null>((resolve) => {
+        resolveExit = resolve;
+      });
+      let closed = false;
+      const mockStdout = new ReadableStream<Uint8Array>({
+        start(controller) {
+          killFn.mockImplementation(() => {
+            if (!closed) {
+              closed = true;
+              controller.close();
+              resolveExit(1);
+            }
+          });
+        },
+      });
+      const mockStderr = new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.close();
+        },
+      });
+
+      spawnMock.mockReturnValue({
+        stdout: mockStdout,
+        stderr: mockStderr,
+        exited: mockExit,
+        exitCode: null,
+        pid: 12345,
+        kill: killFn,
+        ref: vi.fn(),
+        unref: vi.fn(),
+      } as unknown as ReturnType<typeof Bun.spawn>);
+
+      const promise = claudeCodeChat({
+        ...baseOptions,
+        requestTimeoutMs: TIMEOUT_MS,
+        maxRetries: 0,
+      });
+
+      let state: "pending" | "resolved" | "rejected" = "pending";
+      promise.then(
+        () => {
+          state = "resolved";
+        },
+        () => {
+          state = "rejected";
+        },
+      );
+
+      // Before the threshold: kill must not have been called.
+      vi.advanceTimersByTime(TIMEOUT_MS - 1);
+      for (let i = 0; i < 10; i++) await Promise.resolve();
+      expect(killFn).not.toHaveBeenCalled();
+      expect(state).toBe("pending");
+
+      // Cross the threshold: idle timer fires → onAbort → kill → stdout closes → adapter throws.
+      vi.advanceTimersByTime(1);
+      for (let i = 0; i < 50; i++) await Promise.resolve();
+
+      expect(state).toBe("rejected");
+      expect(killFn).toHaveBeenCalledTimes(1);
+    });
+  });
 });
 
 describe("isClaudeCodeAvailable", () => {

package/src/providers/__tests__/deepseek.test.ts

@@ -198,6 +198,7 @@ describe("deepseekChat", () => {
 
     await deepseekChat({
       messages: baseOptions.messages,
+      responseFormat: "json_object",
     });
 
     const body = JSON.parse(
@@ -207,6 +208,18 @@ describe("deepseekChat", () => {
     expect(body.temperature).toBe(0.7);
   });
 
+  it("returns plain text content when responseFormat is omitted (AC-13)", async () => {
+    const events = makeOpenAiSseEvents(["not json, just text"]);
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    const result = await deepseekChat({
+      messages: [{ role: "user", content: "Give me json output please." }],
+    });
+
+    expect(typeof result.content).toBe("string");
+    expect(result.content).toBe("not json, just text");
+  });
+
   it("passes optional parameters when provided", async () => {
     const events = makeOpenAiSseEvents([JSON.stringify({ ok: true })]);
     fetchMock.mockResolvedValue(mockStreamingResponse(events));
@@ -277,7 +290,7 @@ describe("deepseekChat", () => {
       });
     });
 
-    it("defaults usage to zeros when stream provides no usage", async () => {
+    it("returns undefined usage when accumulated stream reports none", async () => {
       const events = [
         'data: {"choices":[{"delta":{"content":"{\\"ok\\":true}"}}]}\n\n',
         'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n',
@@ -287,11 +300,8 @@ describe("deepseekChat", () => {
       fetchMock.mockResolvedValue(mockStreamingResponse(events));
 
       const result = await deepseekChat(baseOptions);
-      expect(result.usage).toEqual({
-        prompt_tokens: 0,
-        completion_tokens: 0,
-        total_tokens: 0,
-      });
+      expect(result.content).toEqual({ ok: true });
+      expect(result.usage).toBeUndefined();
     });
 
     it("skips SSE comment lines and empty lines", async () => {

package/src/providers/__tests__/gemini.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import { geminiChat } from "../gemini.ts";
-import { ProviderJsonModeError, ProviderJsonParseError } from "../types.ts";
+import { ProviderJsonParseError } from "../types.ts";
 import type { GeminiOptions } from "../types.ts";
 import type { Mock } from "vitest";
 
@@ -171,7 +171,7 @@ describe("geminiChat", () => {
     ]);
   });
 
-  it("injects JSON schema into system instruction when responseFormat has json_schema", async () => {
+  it("sets native responseSchema in generationConfig when responseFormat has json_schema (AC-14)", async () => {
     const schema = {
       type: "object",
       properties: { name: { type: "string" } },
@@ -191,29 +191,28 @@ describe("geminiChat", () => {
       (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
 
-    const systemText = body.systemInstruction.parts[0].text as string;
-    expect(systemText).toContain("You are helpful.");
-    expect(systemText).toContain("Respond with JSON matching this schema:");
-    expect(systemText).toContain('"type": "object"');
+    expect(body.generationConfig.responseMimeType).toBe("application/json");
+    expect(body.generationConfig.responseSchema).toEqual(schema);
+    const systemText = body.systemInstruction?.parts?.[0]?.text ?? "";
+    expect(systemText).not.toContain("Respond with JSON matching this schema");
+    expect(systemText).toBe("You are helpful.");
   });
 
-  it("creates systemInstruction from schema alone when no system message exists", async () => {
-    const schema = { type: "object" };
-    const events = makeGeminiSseEvents(JSON.stringify({}));
+  it("does not set responseSchema when responseFormat is a plain json_object", async () => {
+    const events = makeGeminiSseEvents(JSON.stringify({ ok: true }));
     fetchMock.mockResolvedValue(mockStreamingResponse(events));
 
     await geminiChat({
-      messages: [{ role: "user", content: "Do something." }],
-      responseFormat: { json_schema: schema },
+      messages: [{ role: "user", content: "ok" }],
+      responseFormat: "json_object",
     });
 
     const body = JSON.parse(
       (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
 
-    expect(body.systemInstruction).toBeDefined();
-    const systemText = body.systemInstruction.parts[0].text as string;
-    expect(systemText).toContain("Respond with JSON matching this schema:");
+    expect(body.generationConfig.responseMimeType).toBe("application/json");
+    expect(body.generationConfig.responseSchema).toBeUndefined();
   });
 
   it("normalizes usage from Gemini's usageMetadata format", async () => {
@@ -295,13 +294,21 @@ describe("geminiChat", () => {
     expect(result.content).toEqual(jsonPayload);
   });
 
-  it("throws ProviderJsonModeError when responseFormat is invalid", async () => {
-    await expect(
-      geminiChat({
-        ...baseOptions,
-        responseFormat: "text",
-      }),
-    ).rejects.toThrow(ProviderJsonModeError);
+  it("does not set responseMimeType when responseFormat is omitted even if the message says 'json' (AC-13)", async () => {
+    const events = makeGeminiSseEvents("not json, just text");
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    const result = await geminiChat({
+      messages: [{ role: "user", content: "Give me json output please." }],
+    });
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.generationConfig.responseMimeType).toBeUndefined();
+    expect(body.generationConfig.responseSchema).toBeUndefined();
+    expect(typeof result.content).toBe("string");
+    expect(result.content).toBe("not json, just text");
   });
 
   it("throws ProviderJsonParseError for non-JSON text in JSON mode", async () => {
@@ -371,7 +378,7 @@ describe("geminiChat", () => {
     expect(init.signal).toBeInstanceOf(AbortSignal);
   });
 
-  it("handles missing usageMetadata by defaulting to zeros", async () => {
+  it("returns undefined usage when accumulated stream reports none", async () => {
     // Stream without usageMetadata
     const events = [
       `data: ${JSON.stringify({
@@ -382,10 +389,25 @@ describe("geminiChat", () => {
 
     const result = await geminiChat(baseOptions);
 
+    expect(result.content).toEqual({ ok: true });
+    expect(result.usage).toBeUndefined();
+  });
+
+  it("passes through reported partial usage without coercion", async () => {
+    const jsonPayload = { partial: true };
+    const events = [
+      `data: ${JSON.stringify({
+        candidates: [{ content: { parts: [{ text: JSON.stringify(jsonPayload) }], role: "model" }, finishReason: "STOP" }],
+        usageMetadata: { promptTokenCount: 7 },
+      })}\n\n`,
+    ];
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    const result = await geminiChat(baseOptions);
+
+    expect(result.content).toEqual(jsonPayload);
     expect(result.usage).toEqual({
-      prompt_tokens: 0,
-      completion_tokens: 0,
-      total_tokens: 0,
+      prompt_tokens: 7,
     });
   });
 

package/src/providers/__tests__/moonshot.test.ts

@@ -74,6 +74,7 @@ const baseOptions: MoonshotOptions = {
     { role: "system", content: "You are helpful." },
     { role: "user", content: "Return JSON." },
   ],
+  responseFormat: "json",
 };
 
 describe("moonshotChat", () => {
@@ -141,6 +142,18 @@ describe("moonshotChat", () => {
     expect(body.response_format).toBeUndefined();
   });
 
+  it("returns plain text content when responseFormat is omitted (AC-13)", async () => {
+    const events = makeOpenAiSseEvents(["not json, just text"]);
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    const result = await moonshotChat({
+      messages: [{ role: "user", content: "Give me json output please." }],
+    });
+
+    expect(typeof result.content).toBe("string");
+    expect(result.content).toBe("not json, just text");
+  });
+
   it("throws before fetch when messages are empty", async () => {
     await expect(
       moonshotChat({ messages: [] }),
@@ -384,6 +397,20 @@ describe("moonshotChat", () => {
       });
     });
 
+    it("returns undefined usage when accumulated stream reports none", async () => {
+      const events = [
+        'data: {"choices":[{"delta":{"content":"{\\"ok\\":true}"}}]}\n\n',
+        'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n',
+        "data: [DONE]\n\n",
+      ];
+
+      fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+      const result = await moonshotChat(baseOptions);
+      expect(result.content).toEqual({ ok: true });
+      expect(result.usage).toBeUndefined();
+    });
+
     it("retries on timeout then succeeds on second attempt", async () => {
       const events = makeOpenAiSseEvents([JSON.stringify({ ok: true })]);