@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/providers/anthropic.ts

@@ -10,6 +10,7 @@ import {
   tryParseJSON,
   createProviderError,
   ensureJsonResponseFormat,
+  isJsonResponseFormat,
 } from "./base.ts";
 import {
   IdleTimeoutController,
@@ -25,7 +26,6 @@ const ANTHROPIC_VERSION = "2023-06-01";
 const DEFAULT_MODEL = "claude-3-sonnet";
 const DEFAULT_TEMPERATURE = 0.7;
 const DEFAULT_MAX_TOKENS = 8192;
-const DEFAULT_RESPONSE_FORMAT = "json";
 const DEFAULT_MAX_RETRIES = 3;
 
 export async function anthropicChat(
@@ -36,15 +36,17 @@ export async function anthropicChat(
     model = DEFAULT_MODEL,
     temperature = DEFAULT_TEMPERATURE,
     maxTokens = DEFAULT_MAX_TOKENS,
-    responseFormat = DEFAULT_RESPONSE_FORMAT,
+    responseFormat,
     topP,
     stop,
     maxRetries = DEFAULT_MAX_RETRIES,
     requestTimeoutMs,
   } = options;
 
-  // Validate JSON response format — if this throws, we are not in JSON mode
-  ensureJsonResponseFormat(responseFormat, "anthropic");
+  const jsonMode = isJsonResponseFormat(responseFormat);
+  if (jsonMode) {
+    ensureJsonResponseFormat(responseFormat, "anthropic");
+  }
 
   const { systemMsg, userMessages, assistantMessages } =
     extractMessages(messages);
@@ -86,6 +88,7 @@ export async function anthropicChat(
         model,
         apiKey ?? "",
         requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        jsonMode,
       );
     } catch (err) {
       lastError = err;
@@ -109,6 +112,7 @@ async function anthropicStreamChat(
   model: string,
   apiKey: string,
   timeoutMs: number,
+  jsonMode: boolean,
 ): Promise<AdapterResponse> {
   const idle = new IdleTimeoutController(timeoutMs);
 
@@ -151,16 +155,24 @@ async function anthropicStreamChat(
   const stripped = stripMarkdownFences(rawText);
   const parsed = tryParseJSON(stripped);
 
-  if (typeof parsed === "string") {
-    throw new ProviderJsonParseError(
-      "anthropic",
-      model,
-      parsed.slice(0, 200),
-    );
+  if (jsonMode) {
+    if (typeof parsed === "string") {
+      throw new ProviderJsonParseError(
+        "anthropic",
+        model,
+        parsed.slice(0, 200),
+        undefined,
+        {
+          text: rawText,
+          usage,
+        },
+      );
+    }
+    return { content: parsed as Record<string, unknown>, text: rawText, usage };
   }
 
   return {
-    content: parsed as Record<string, unknown>,
+    content: rawText,
     text: rawText,
     usage,
   };

package/src/providers/base.ts

@@ -223,3 +223,22 @@ export function ensureJsonResponseFormat(
 
   throw new ProviderJsonModeError(providerName);
 }
+
+export function isJsonResponseFormat(responseFormat: unknown): boolean {
+  if (typeof responseFormat === "string") {
+    return responseFormat === "json" || responseFormat === "json_object";
+  }
+  if (responseFormat && typeof responseFormat === "object") {
+    const obj = responseFormat as Record<string, unknown>;
+    return obj.type === "json_object" || obj.json_schema != null;
+  }
+  return false;
+}
+
+export function extractResponseSchema(responseFormat: unknown): unknown | undefined {
+  if (responseFormat && typeof responseFormat === "object") {
+    const obj = responseFormat as Record<string, unknown>;
+    if (obj.json_schema != null) return obj.json_schema;
+  }
+  return undefined;
+}

package/src/providers/claude-code.ts

@@ -6,6 +6,7 @@ import {
   ensureJsonResponseFormat,
   extractMessages,
   isRetryableError,
+  isJsonResponseFormat,
   sleep,
   stripMarkdownFences,
   tryParseJSON,
@@ -20,16 +21,9 @@ import type { ClaudeCodeOptions, AdapterResponse } from "./types.ts";
 
 const DEFAULT_MODEL = "sonnet";
 const DEFAULT_MAX_TURNS = 1;
-const DEFAULT_RESPONSE_FORMAT = "json";
 const DEFAULT_MAX_RETRIES = 3;
 const AVAILABILITY_TIMEOUT_MS = 5_000;
 
-const ZERO_USAGE = {
-  prompt_tokens: 0,
-  completion_tokens: 0,
-  total_tokens: 0,
-} as const;
-
 export async function claudeCodeChat(
   options: ClaudeCodeOptions,
 ): Promise<AdapterResponse> {
@@ -38,11 +32,15 @@ export async function claudeCodeChat(
     model = DEFAULT_MODEL,
     maxTokens,
     maxTurns = DEFAULT_MAX_TURNS,
-    responseFormat = DEFAULT_RESPONSE_FORMAT,
+    responseFormat,
     maxRetries = DEFAULT_MAX_RETRIES,
+    requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   } = options;
 
-  ensureJsonResponseFormat(responseFormat, "claudecode");
+  const jsonMode = isJsonResponseFormat(responseFormat);
+  if (jsonMode) {
+    ensureJsonResponseFormat(responseFormat, "claudecode");
+  }
 
   const { systemMsg, userMsg } = extractMessages(messages);
 
@@ -72,7 +70,7 @@ export async function claudeCodeChat(
         stderr: "pipe",
       });
 
-      const idle = new IdleTimeoutController(DEFAULT_REQUEST_TIMEOUT_MS);
+      const idle = new IdleTimeoutController(requestTimeoutMs);
 
       // Kill the subprocess if the idle timeout fires
       const onAbort = () => proc.kill();
@@ -94,18 +92,29 @@ export async function claudeCodeChat(
       const cleanedText = stripMarkdownFences(accumulated.text);
       const parsed = tryParseJSON(cleanedText);
 
-      if (typeof parsed === "string") {
-        throw new ProviderJsonParseError(
-          "claudecode",
-          model,
-          parsed.slice(0, 200),
-        );
+      if (jsonMode) {
+        if (typeof parsed === "string") {
+          throw new ProviderJsonParseError(
+            "claudecode",
+            model,
+            parsed.slice(0, 200),
+            undefined,
+            {
+              text: accumulated.text,
+              usage: accumulated.usage,
+            },
+          );
+        }
+        return {
+          content: parsed as Record<string, unknown>,
+          text: accumulated.text,
+          raw: accumulated.text,
+        };
       }
 
       return {
-        content: parsed as Record<string, unknown>,
+        content: accumulated.text,
         text: accumulated.text,
-        usage: { ...ZERO_USAGE },
         raw: accumulated.text,
       };
     } catch (err) {

package/src/providers/deepseek.ts

@@ -5,6 +5,7 @@ import {
   DEFAULT_REQUEST_TIMEOUT_MS,
   extractMessages,
   isRetryableError,
+  isJsonResponseFormat,
   sleep,
   stripMarkdownFences,
   tryParseJSON,
@@ -14,7 +15,6 @@ import { ProviderJsonParseError } from "./types.ts";
 import type {
   DeepSeekOptions,
   AdapterResponse,
-  ResponseFormatObject,
 } from "./types.ts";
 import {
   IdleTimeoutController,
@@ -26,26 +26,8 @@ import {
 const DEEPSEEK_API_URL = "https://api.deepseek.com/chat/completions";
 const DEFAULT_MODEL = "deepseek-chat";
 const DEFAULT_TEMPERATURE = 0.7;
-const DEFAULT_RESPONSE_FORMAT = "json_object";
 const DEFAULT_MAX_RETRIES = 3;
 
-/**
- * Determines whether the response format indicates JSON mode.
- * Returns true for "json", "json_object", { type: "json_object" }, { json_schema: ... }.
- */
-function isJsonMode(
-  responseFormat: string | ResponseFormatObject | undefined,
-): boolean {
-  if (!responseFormat) return false;
-  if (typeof responseFormat === "string") {
-    return responseFormat === "json" || responseFormat === "json_object";
-  }
-  return (
-    responseFormat.type === "json_object" ||
-    responseFormat.json_schema != null
-  );
-}
-
 export async function deepseekChat(
   options: DeepSeekOptions,
 ): Promise<AdapterResponse> {
@@ -54,7 +36,7 @@ export async function deepseekChat(
     model = DEFAULT_MODEL,
     temperature = DEFAULT_TEMPERATURE,
     maxTokens,
-    responseFormat = DEFAULT_RESPONSE_FORMAT,
+    responseFormat,
     topP,
     stop,
     maxRetries = DEFAULT_MAX_RETRIES,
@@ -66,7 +48,7 @@ export async function deepseekChat(
     ? Math.max(0, Math.trunc(maxRetries))
     : DEFAULT_MAX_RETRIES;
 
-  const jsonMode = isJsonMode(responseFormat);
+  const jsonMode = isJsonResponseFormat(responseFormat);
 
   const { systemMsg, userMessages, assistantMessages } =
     extractMessages(messages);
@@ -159,21 +141,20 @@ export async function deepseekChat(
           "deepseek",
           model,
           parsed.slice(0, 200),
+          undefined,
+          {
+            text: rawText,
+            usage: accumulated.usage,
+          },
         );
       }
 
-      const usage = accumulated.usage ?? {
-        prompt_tokens: 0,
-        completion_tokens: 0,
-        total_tokens: 0,
-      };
-
       return {
         content:
           typeof parsed === "string"
             ? parsed
             : (parsed as Record<string, unknown>),
-        usage,
+        usage: accumulated.usage,
       };
     } catch (err) {
       lastError = err;

package/src/providers/gemini.ts

@@ -10,13 +10,14 @@ import {
   tryParseJSON,
   createProviderError,
   ensureJsonResponseFormat,
+  isJsonResponseFormat,
+  extractResponseSchema,
 } from "./base.ts";
 import { IdleTimeoutController, parseGeminiSse, accumulateStream } from "./stream-accumulator.ts";
 import { ProviderJsonParseError } from "./types.ts";
 import type {
   GeminiOptions,
   AdapterResponse,
-  ResponseFormatObject,
 } from "./types.ts";
 
 const DEFAULT_MODEL = "gemini-2.5-flash";
@@ -33,39 +34,6 @@ const SAFETY_SETTINGS = [
   { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
 ];
 
-/**
- * Determines whether the response format indicates JSON mode.
- * Returns true for "json", "json_object", { type: "json_object" }, { json_schema: ... }.
- */
-function isJsonMode(
-  responseFormat: string | ResponseFormatObject | undefined,
-): boolean {
-  if (!responseFormat) return false;
-  if (typeof responseFormat === "string") {
-    return responseFormat === "json" || responseFormat === "json_object";
-  }
-  return (
-    responseFormat.type === "json_object" ||
-    responseFormat.json_schema != null
-  );
-}
-
-/**
- * Extracts a JSON schema object from the responseFormat, if present.
- */
-function extractJsonSchema(
-  responseFormat: string | ResponseFormatObject | undefined,
-): unknown | undefined {
-  if (
-    responseFormat &&
-    typeof responseFormat === "object" &&
-    responseFormat.json_schema != null
-  ) {
-    return responseFormat.json_schema;
-  }
-  return undefined;
-}
-
 export async function geminiChat(
   options: GeminiOptions,
 ): Promise<AdapterResponse> {
@@ -84,12 +52,11 @@ export async function geminiChat(
     presencePenalty: _presencePenalty,
   } = options;
 
-  const jsonMode = isJsonMode(responseFormat);
-
-  // Validate JSON response format if one was specified
-  if (responseFormat) {
+  const jsonMode = isJsonResponseFormat(responseFormat);
+  if (jsonMode) {
     ensureJsonResponseFormat(responseFormat, "gemini");
   }
+  const jsonSchema = extractResponseSchema(responseFormat);
 
   const { systemMsg, userMessages, assistantMessages } =
     extractMessages(messages);
@@ -108,25 +75,21 @@ export async function geminiChat(
     parts: [{ text: m.content }],
   }));
 
-  // Build system instruction, optionally injecting JSON schema
-  const jsonSchema = extractJsonSchema(responseFormat);
-  let systemText = systemMsg;
-  if (jsonSchema) {
-    const schemaStr = JSON.stringify(jsonSchema, null, 2);
-    const schemaInstruction = `\n\nRespond with JSON matching this schema:\n${schemaStr}`;
-    systemText = systemText ? systemText + schemaInstruction : schemaInstruction.trimStart();
-  }
-
-  const systemInstruction = systemText
-    ? { parts: [{ text: systemText }] }
+  const systemInstruction = systemMsg
+    ? { parts: [{ text: systemMsg }] }
     : undefined;
 
-  // Build generationConfig
+  // Build generationConfig — wire native structured output when schema is present.
   const generationConfig: Record<string, unknown> = { temperature };
   if (maxTokens != null) generationConfig["maxOutputTokens"] = maxTokens;
   if (topP != null) generationConfig["topP"] = topP;
   if (stop != null) generationConfig["stopSequences"] = Array.isArray(stop) ? stop : [stop];
-  if (jsonMode) generationConfig["responseMimeType"] = "application/json";
+  if (jsonSchema != null) {
+    generationConfig["responseMimeType"] = "application/json";
+    generationConfig["responseSchema"] = jsonSchema;
+  } else if (jsonMode) {
+    generationConfig["responseMimeType"] = "application/json";
+  }
 
   const baseUrl =
     process.env["GEMINI_BASE_URL"] ?? DEFAULT_BASE_URL;
@@ -189,19 +152,18 @@ export async function geminiChat(
           "gemini",
           model,
           parsed.slice(0, 200),
+          undefined,
+          {
+            text: rawText,
+            usage: streamUsage,
+          },
         );
       }
 
-      const usage = streamUsage ?? {
-        prompt_tokens: 0,
-        completion_tokens: 0,
-        total_tokens: 0,
-      };
-
       return {
         content: typeof parsed === "string" ? parsed : (parsed as Record<string, unknown>),
         text: rawText,
-        usage,
+        usage: streamUsage,
       };
     } catch (err) {
       lastError = err;

package/src/providers/moonshot.ts

@@ -6,6 +6,7 @@ import {
   extractMessages,
   ensureMessagesPresent,
   isRetryableError,
+  isJsonResponseFormat,
   sleep,
   stripMarkdownFences,
   tryParseJSON,
@@ -52,6 +53,8 @@ export async function moonshotChat(
 
   ensureMessagesPresent(messages, "moonshot");
 
+  const jsonMode = isJsonResponseFormat(responseFormat);
+
   const { systemMsg, userMessages, assistantMessages } =
     extractMessages(messages);
 
@@ -116,7 +119,7 @@ export async function moonshotChat(
             return deepseekChat({
               messages,
               model: deepseekModel,
-              responseFormat: responseFormat ?? "json_object",
+              responseFormat,
               requestTimeoutMs,
             });
           }
@@ -144,24 +147,25 @@ export async function moonshotChat(
       const stripped = stripMarkdownFences(rawText);
       const parsed = tryParseJSON(stripped);
 
-      // Always in JSON mode — string result means parse failure
-      if (typeof parsed === "string") {
+      if (jsonMode && typeof parsed === "string") {
         throw new ProviderJsonParseError(
           "moonshot",
           model,
           parsed.slice(0, 200),
+          undefined,
+          {
+            text: rawText,
+            usage: accumulated.usage,
+          },
         );
       }
 
-      const usage = accumulated.usage ?? {
-        prompt_tokens: 0,
-        completion_tokens: 0,
-        total_tokens: 0,
-      };
-
       return {
-        content: parsed as Record<string, unknown>,
-        usage,
+        content:
+          typeof parsed === "string"
+            ? parsed
+            : (parsed as Record<string, unknown>),
+        usage: accumulated.usage,
         raw: { accumulated: rawText },
       };
     } catch (err) {