@juspay/neurolink 12.37.4 → 12.38.0

package/dist/providers/anthropic/client.js

@@ -41,14 +41,14 @@ import { buildNoOutputSentinel, stampNoOutputSpan, } from "../../utils/noOutputS
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { resolveClaudeMaxTokens } from "../../utils/tokenLimits.js";
 import { toAnthropicImageBlock, fileToAnthropicBlock, } from "../anthropicImageBlocks.js";
-import { resolveSamplingParams } from "../../models/modelRegistry.js";
+import { modelSupportsForcedToolChoice, resolveSamplingParams, } from "../../models/modelRegistry.js";
 import { createDeferredAnalytics, stringifyToolInput, } from "../openaiChatCompletionsClient.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { ANTHROPIC_BETA_HEADERS } from "./constants.js";
 import { cacheControlOf, withLastToolCacheBreakpoint } from "./cacheControl.js";
 import { createNativeGenerateGuard } from "../../context/nativeGenerateGuard.js";
-import { appendFinalResultInstruction, appendFinalResultTool, FINAL_RESULT_TOOL_NAME, } from "./structuredOutput.js";
+import { appendFinalResultInstruction, appendFinalResultTool, appendToolAnswerInstruction, FINAL_RESULT_TOOL_NAME, } from "./structuredOutput.js";
 // AnthropicProviderConfig is imported from types/providers.ts
 // Re-export for backward compatibility
 // Configuration helpers - now using consolidated utility
@@ -424,6 +424,23 @@ const toolChoiceToAnthropic = (choice) => {
     }
     return undefined;
 };
+/**
+ * Claude 5.5 / 5.1 models answer a forced choice with a 400, so for them it
+ * becomes `auto`: the tool stays declared and the model still picks it.
+ */
+const relaxForcedToolChoice = (modelId, choice) => {
+    if ((choice?.type !== "any" && choice?.type !== "tool") ||
+        modelSupportsForcedToolChoice(modelId)) {
+        return choice;
+    }
+    logger.warn(`[anthropic] ${modelId} rejects tool_choice "${choice.type}"; sending "auto" instead`);
+    return {
+        type: "auto",
+        ...(choice.disable_parallel_tool_use !== undefined
+            ? { disable_parallel_tool_use: choice.disable_parallel_tool_use }
+            : {}),
+    };
+};
 /** Map Anthropic stop_reason onto the V3 unified finish reason. */
 const mapAnthropicStopReason = (raw) => {
     switch (raw) {
@@ -1107,8 +1124,15 @@ export class AnthropicProvider extends BaseProvider {
                             input_schema: schema,
                         },
                     ];
-                    toolChoice = { type: "tool", name: jsonTool };
+                    if (modelSupportsForcedToolChoice(modelId)) {
+                        toolChoice = { type: "tool", name: jsonTool };
+                    }
+                    else {
+                        toolChoice = undefined;
+                        system = appendToolAnswerInstruction(system, jsonTool);
+                    }
                 }
+                toolChoice = relaxForcedToolChoice(modelId, toolChoice);
                 // Additive structured output: when the caller wants a schema AND real
                 // tools, the forced-json path above cannot be used (it replaces the
                 // tools array), and structured output is excluded for this surface
@@ -1458,7 +1482,7 @@ export class AnthropicProvider extends BaseProvider {
             options.disableInternalFallback === true;
         // The native loop bypasses BaseProvider.executeGeneration, so the turn
         // budget has to be composed here or it stops existing for this provider.
-        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback);
+        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback, options);
     }
     async executeNativeGenerate(options) {
         const startTime = Date.now();
@@ -1717,7 +1741,7 @@ export class AnthropicProvider extends BaseProvider {
         }
         const modelId = this.modelName || getDefaultAnthropicModel();
         const anthropicToolChoice = shouldUseTools && anthropicTools && anthropicTools.length > 0
-            ? toolChoiceToAnthropic(resolveToolChoice(options, toolsRecord, shouldUseTools))
+            ? relaxForcedToolChoice(modelId, toolChoiceToAnthropic(resolveToolChoice(options, toolsRecord, shouldUseTools)))
             : undefined;
         // Extended thinking: enabled when the caller supplies an explicit token
         // budget (mirrors the previous experimental_thinking gating). Thinking

package/dist/providers/anthropic/structuredOutput.d.ts

@@ -17,8 +17,10 @@ import type Anthropic from "@anthropic-ai/sdk";
  */
 /** Internal tool name — filtered out of every returned tool call / execution. */
 export declare const FINAL_RESULT_TOOL_NAME = "final_result";
+/** The system-prompt instruction to answer through the named tool. */
+export declare function toolAnswerInstruction(toolName: string): string;
 /** Appended to the system prompt whenever the final_result tool is in play. */
-export declare const FINAL_RESULT_INSTRUCTION = "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
+export declare const FINAL_RESULT_INSTRUCTION: string;
 /**
  * Build the `final_result` tool definition from a JSON Schema.
  *
@@ -47,6 +49,7 @@ export declare function appendFinalResultTool(tools: Anthropic.Messages.Tool[] |
  * existing one: rewriting a block that carries a `cache_control` marker would
  * change the cached prefix and invalidate the prompt cache on every turn.
  */
+export declare function appendToolAnswerInstruction(system: string | Anthropic.Messages.TextBlockParam[] | undefined, toolName: string): string | Anthropic.Messages.TextBlockParam[];
 export declare function appendFinalResultInstruction(system: string | Anthropic.Messages.TextBlockParam[] | undefined): string | Anthropic.Messages.TextBlockParam[];
 /**
  * Canonical JSON text for a `final_result` payload.

package/dist/providers/anthropic/structuredOutput.js

@@ -19,8 +19,12 @@ import { inlineJsonSchema } from "../../utils/schemaConversion.js";
 /** Internal tool name — filtered out of every returned tool call / execution. */
 export const FINAL_RESULT_TOOL_NAME = "final_result";
 const FINAL_RESULT_TOOL_DESCRIPTION = "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.";
+/** The system-prompt instruction to answer through the named tool. */
+export function toolAnswerInstruction(toolName) {
+    return `\n\nIMPORTANT: You MUST call the '${toolName}' tool to return your response in the required structured format. Do not respond with plain text - always use the ${toolName} tool.`;
+}
 /** Appended to the system prompt whenever the final_result tool is in play. */
-export const FINAL_RESULT_INSTRUCTION = "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
+export const FINAL_RESULT_INSTRUCTION = toolAnswerInstruction(FINAL_RESULT_TOOL_NAME);
 /**
  * Build the `final_result` tool definition from a JSON Schema.
  *
@@ -71,14 +75,18 @@ export function appendFinalResultTool(tools, jsonSchema) {
  * existing one: rewriting a block that carries a `cache_control` marker would
  * change the cached prefix and invalidate the prompt cache on every turn.
  */
-export function appendFinalResultInstruction(system) {
+export function appendToolAnswerInstruction(system, toolName) {
+    const instruction = toolAnswerInstruction(toolName);
     if (system === undefined) {
-        return FINAL_RESULT_INSTRUCTION.trim();
+        return instruction.trim();
     }
     if (typeof system === "string") {
-        return system + FINAL_RESULT_INSTRUCTION;
+        return system + instruction;
     }
-    return [...system, { type: "text", text: FINAL_RESULT_INSTRUCTION.trim() }];
+    return [...system, { type: "text", text: instruction.trim() }];
+}
+export function appendFinalResultInstruction(system) {
+    return appendToolAnswerInstruction(system, FINAL_RESULT_TOOL_NAME);
 }
 /**
  * Canonical JSON text for a `final_result` payload.

package/dist/providers/catalog/cerebras.json

@@ -9,7 +9,7 @@
     },
     "models": {
         "default": "gpt-oss-120b",
-        "fallbacks": ["gpt-oss-120b", "gemma-4-31b"],
+        "fallbacks": ["gpt-oss-120b"],
         "defaultContextWindow": 65536,
         "defaultMaxOutputTokens": 8192,
         "catalog": {
@@ -29,13 +29,12 @@
                     "input": 0.99,
                     "output": 1.49
                 },
-                "vision": true,
-                "status": "production",
-                "description": "Google Gemma 4 31B — vision-capable"
+                "vision": false,
+                "status": "retired",
+                "description": "Retired 2026-09 — gone from the authenticated /v1/models roster; the nightly vision test has failed on it since 2026-09-10"
             }
         },
-        "visionModel": "gemma-4-31b",
-        "topModels": ["gpt-oss-120b", "gemma-4-31b"]
+        "topModels": ["gpt-oss-120b"]
     },
     "capabilities": {
         "text": true,
@@ -68,8 +67,8 @@
     },
     "evidence": {
         "rosterVerified": {
-            "date": "2026-08-27",
-            "method": "authenticated GET /v1/models"
+            "date": "2026-09-28",
+            "method": "authenticated GET /v1/models — roster is now gpt-oss-120b and qwen-3.8-27b; gemma-4-31b is gone, so it is retired and Cerebras has no verified vision model. qwen-3.8-27b is not added: the account answers 402 payment_required, so no chat call could verify it"
         },
         "authProbe": {
             "date": "2026-08-26",

package/dist/providers/catalog/fireworks.json

@@ -8,12 +8,11 @@
         "baseURL": "https://api.fireworks.ai/inference/v1"
     },
     "models": {
-        "default": "accounts/fireworks/models/kimi-k2p6",
+        "default": "accounts/fireworks/models/kimi-k3",
         "fallbackModelName": "accounts/fireworks/models/gpt-oss-120b",
         "fallbacks": [
-            "accounts/fireworks/models/kimi-k2p6",
-            "accounts/fireworks/models/gpt-oss-120b",
             "accounts/fireworks/models/kimi-k3",
+            "accounts/fireworks/models/gpt-oss-120b",
             "accounts/fireworks/models/qwen3p8-max",
             "accounts/fireworks/models/glm-5p3"
         ],
@@ -22,9 +21,9 @@
         "catalog": {
             "accounts/fireworks/models/kimi-k2p6": {
                 "enumMember": "KIMI_K2P6",
-                "vision": true,
-                "status": "production",
-                "description": "Recommended - Kimi K2.6, Moonshot flagship; vision-capable"
+                "vision": false,
+                "status": "retired",
+                "description": "Retired 2026-09 — still on the Fireworks roster, but a real chat call returns 404 'not deployed' (since the 2026-09-26 nightly)"
             },
             "accounts/fireworks/models/gpt-oss-120b": {
                 "enumMember": "GPT_OSS_120B",
@@ -36,7 +35,7 @@
                 "enumMember": "KIMI_K3",
                 "vision": true,
                 "status": "production",
-                "description": "Kimi K3 — newest Moonshot generation; vision-capable"
+                "description": "Recommended - Kimi K3, newest Moonshot generation; vision-capable"
             },
             "accounts/fireworks/models/qwen3p8-max": {
                 "enumMember": "QWEN3P8_MAX",
@@ -106,9 +105,8 @@
             }
         },
         "topModels": [
-            "accounts/fireworks/models/kimi-k2p6",
-            "accounts/fireworks/models/gpt-oss-120b",
             "accounts/fireworks/models/kimi-k3",
+            "accounts/fireworks/models/gpt-oss-120b",
             "accounts/fireworks/models/qwen3p8-max"
         ]
     },
@@ -143,12 +141,12 @@
     },
     "evidence": {
         "rosterVerified": {
-            "date": "2026-08-30",
+            "date": "2026-09-28",
             "method": "GET /models against the live account, cross-checked with a real chat call per id"
         },
         "liveMatrix": {
-            "date": "2026-08-30",
-            "result": "The previous default, deepseek-v4-pro, is the reason a roster listing is never sufficient evidence here: it is still listed but a real chat call hangs past 120s, so the default moved to kimi-k2p6 (200 OK). Six ids return 404 'not deployed', including all three old vision models. Vision did not disappear with them: re-tested with a valid 64x64 PNG, kimi-k2p6, kimi-k3 and qwen3p8-max all describe the image correctly, while glm-5p3 answers 'does not support image inputs'. gpt-oss-20b is listed but 404s and was therefore not added."
+            "date": "2026-09-28",
+            "result": "kimi-k2p6 is still listed on /models but a real chat call now returns 404 'not deployed', which failed the nightly model-liveness gate from 2026-09-26 and sent the matrix vision test down the text-only fallback. kimi-k3 answers a text call and a call carrying a PNG with 200, so it becomes the default; gpt-oss-120b, qwen3p8-max and glm-5p3 also answer text calls. Earlier (2026-08-30): deepseek-v4-pro was listed but hung past 120s, six ids returned 404 'not deployed', and glm-5p3 answers 'does not support image inputs'."
         },
         "addedInPR": "https://github.com/juspay/neurolink/pull/1587"
     }

package/dist/providers/googleVertex/client.d.ts

@@ -222,9 +222,9 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * clamped below the ceiling rather than passed through — an over-large
      * budget is a 400 from the API.
      *
-     * `useFinalResultTool` (schema / structured-output mode) always pairs with
-     * a forced `tool_choice:{type:"any"}` in the request built right after this
-     * call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
+     * `forcesToolChoice` (schema mode on a model that accepts a forced choice)
+     * pairs with a forced `tool_choice:{type:"any"}` in the request built right
+     * after this call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
      * that forces tool use: a live 400, "Thinking may not be enabled when
      * tool_choice forces tool use." So `thinking` is omitted entirely in that
      * mode, preserving the prior (pre-thinking-fix) behaviour of silently

package/dist/providers/googleVertex/client.js

@@ -46,7 +46,7 @@ import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, }
 import { calculateCost } from "../../utils/pricing.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { resolveSamplingParams } from "../../models/modelRegistry.js";
+import { modelSupportsForcedToolChoice, resolveSamplingParams, } from "../../models/modelRegistry.js";
 import { sanitizeAnthropicMessagesForTrace } from "../../utils/anthropicTraceSanitizer.js";
 import { extractToolFailureText } from "../../utils/mcpErrorText.js";
 // Import proper types for multimodal message handling
@@ -707,6 +707,20 @@ async function collectVertexStreamChunks(stream, channel, hooks = {}) {
         ...(stepReasoningTokens ? { reasoningTokens: stepReasoningTokens } : {}),
     };
 }
+/**
+ * The answer text of an unforced finalization reply. Text that leads into a
+ * further tool call is preamble, not an answer, so a reply still asking for a
+ * tool yields none.
+ */
+function finalizationAnswerText(content) {
+    if (content.some((block) => block.type === "tool_use")) {
+        return "";
+    }
+    return content
+        .filter((block) => block.type === "text")
+        .map((b) => b.text)
+        .join("");
+}
 export class GoogleVertexProvider extends BaseProvider {
     projectId;
     location;
@@ -2949,9 +2963,9 @@ export class GoogleVertexProvider extends BaseProvider {
      * clamped below the ceiling rather than passed through — an over-large
      * budget is a 400 from the API.
      *
-     * `useFinalResultTool` (schema / structured-output mode) always pairs with
-     * a forced `tool_choice:{type:"any"}` in the request built right after this
-     * call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
+     * `forcesToolChoice` (schema mode on a model that accepts a forced choice)
+     * pairs with a forced `tool_choice:{type:"any"}` in the request built right
+     * after this call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
      * that forces tool use: a live 400, "Thinking may not be enabled when
      * tool_choice forces tool use." So `thinking` is omitted entirely in that
      * mode, preserving the prior (pre-thinking-fix) behaviour of silently
@@ -2968,8 +2982,8 @@ export class GoogleVertexProvider extends BaseProvider {
     buildClaudeThinkingParam(
     // Structural, not TextGenerationOptions: the streaming caller passes
     // StreamOptions, and only these two fields are read.
-    options, maxTokens, useFinalResultTool) {
-        if (useFinalResultTool) {
+    options, maxTokens, forcesToolChoice) {
+        if (forcesToolChoice) {
             if (options.thinkingConfig?.enabled) {
                 logger.debug("[GoogleVertex] Omitting thinking: schema mode forces tool_choice:any, which Anthropic rejects alongside thinking");
             }
@@ -3215,7 +3229,10 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(options.topP !== undefined && { topP: options.topP }),
         }, "vertex.anthropic.stream");
         const streamMaxTokens = resolveClaudeMaxTokens(modelName, options.maxTokens);
-        const streamThinking = this.buildClaudeThinkingParam(options, streamMaxTokens, useFinalResultTool);
+        // Claude 5.5 / 5.1 400 on a forced tool_choice; schema mode leaves them on
+        // auto, steered by the final_result instruction already in the prompt.
+        const forceFinalResult = useFinalResultTool && modelSupportsForcedToolChoice(modelName);
+        const streamThinking = this.buildClaudeThinkingParam(options, streamMaxTokens, forceFinalResult);
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (e.g. 64K for Sonnet 4.x)
@@ -3226,7 +3243,7 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(streamThinking && { thinking: streamThinking }),
             messages: messages,
             ...(tools && tools.length > 0 && { tools }),
-            ...(useFinalResultTool && { tool_choice: { type: "any" } }),
+            ...(forceFinalResult && { tool_choice: { type: "any" } }),
             ...(systemPromptWithSchema && { system: systemPromptWithSchema }),
             ...(streamSampling.temperature !== undefined && {
                 temperature: streamSampling.temperature,
@@ -3858,10 +3875,15 @@ export class GoogleVertexProvider extends BaseProvider {
                             const finalizationStream = await client.messages.stream({
                                 ...requestParams,
                                 max_tokens: terminalMaxTokens,
-                                tool_choice: {
-                                    type: "tool",
-                                    name: "final_result",
-                                },
+                                // Resized, not inherited: terminalMaxTokens can sit below the
+                                // budget requestParams' thinking was sized for.
+                                thinking: this.buildClaudeThinkingParam(options, terminalMaxTokens, forceFinalResult),
+                                ...(forceFinalResult && {
+                                    tool_choice: {
+                                        type: "tool",
+                                        name: "final_result",
+                                    },
+                                }),
                                 ...(cachedFinal.system !== undefined && {
                                     system: cachedFinal.system,
                                 }),
@@ -3905,11 +3927,23 @@ export class GoogleVertexProvider extends BaseProvider {
                                 logger.debug("[GoogleVertex] Forced finalization returned structured output (stream)", { keys: Object.keys(forcedFinalResult.input) });
                             }
                             else {
-                                const capMessage = hitContextLimit
-                                    ? buildContextCapMessage(externalToolCallCount)
-                                    : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
-                                channel.push({ content: capMessage });
-                                aggregatedTurnText += capMessage;
+                                // Unforced (the model refuses a forced choice), the call may
+                                // answer in text instead; keep that answer over a cap notice.
+                                const finalizationText = forceFinalResult
+                                    ? ""
+                                    : finalizationAnswerText(response.content);
+                                if (finalizationText) {
+                                    synthesizedFinalAnswer = true;
+                                    channel.push({ content: finalizationText });
+                                    aggregatedTurnText += finalizationText;
+                                }
+                                else {
+                                    const capMessage = hitContextLimit
+                                        ? buildContextCapMessage(externalToolCallCount)
+                                        : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                                    channel.push({ content: capMessage });
+                                    aggregatedTurnText += capMessage;
+                                }
                             }
                         }
                         catch (error) {
@@ -4484,7 +4518,10 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(options.topP !== undefined && { topP: options.topP }),
         }, "vertex.anthropic.generate");
         const generateMaxTokens = resolveClaudeMaxTokens(modelName, options.maxTokens);
-        const generateThinking = this.buildClaudeThinkingParam(options, generateMaxTokens, useFinalResultTool);
+        // Claude 5.5 / 5.1 400 on a forced tool_choice; schema mode leaves them on
+        // auto, steered by the final_result instruction already in the prompt.
+        const forceFinalResult = useFinalResultTool && modelSupportsForcedToolChoice(modelName);
+        const generateThinking = this.buildClaudeThinkingParam(options, generateMaxTokens, forceFinalResult);
         const requestParams = {
             model: modelName,
             // Default to the model's real output ceiling (see stream path note).
@@ -4492,7 +4529,7 @@ export class GoogleVertexProvider extends BaseProvider {
             ...(generateThinking && { thinking: generateThinking }),
             messages,
             ...(tools && tools.length > 0 && { tools }),
-            ...(useFinalResultTool && { tool_choice: { type: "any" } }),
+            ...(forceFinalResult && { tool_choice: { type: "any" } }),
             ...(systemPromptWithSchema && { system: systemPromptWithSchema }),
             ...(generateSampling.temperature !== undefined && {
                 temperature: generateSampling.temperature,
@@ -4901,10 +4938,15 @@ export class GoogleVertexProvider extends BaseProvider {
                     const response = await withTimeout(client.messages.create({
                         ...requestParams,
                         max_tokens: terminalMaxTokens,
-                        tool_choice: {
-                            type: "tool",
-                            name: "final_result",
-                        },
+                        // Resized, not inherited: terminalMaxTokens can sit below the
+                        // budget requestParams' thinking was sized for.
+                        thinking: this.buildClaudeThinkingParam(options, terminalMaxTokens, forceFinalResult),
+                        ...(forceFinalResult && {
+                            tool_choice: {
+                                type: "tool",
+                                name: "final_result",
+                            },
+                        }),
                         ...(cachedFinal.system !== undefined && {
                             system: cachedFinal.system,
                         }),
@@ -4928,9 +4970,20 @@ export class GoogleVertexProvider extends BaseProvider {
                         logger.debug("[GoogleVertex] Forced finalization returned structured output (generate)", { keys: Object.keys(structuredOutput) });
                     }
                     else {
-                        finalText = hitContextLimit
-                            ? buildContextCapMessage(externalToolCallCount)
-                            : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                        // Unforced (the model refuses a forced choice), the call may
+                        // answer in text instead; keep that answer over a cap notice.
+                        const finalizationText = forceFinalResult
+                            ? ""
+                            : finalizationAnswerText(response.content);
+                        if (finalizationText) {
+                            finalText = finalizationText;
+                            synthesizedFinalAnswer = true;
+                        }
+                        else {
+                            finalText = hitContextLimit
+                                ? buildContextCapMessage(externalToolCallCount)
+                                : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
+                        }
                     }
                 }
                 catch (error) {

package/dist/providers/laya.js

@@ -2,25 +2,7 @@ import { LayaModels } from "../constants/enums.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlForError } from "../utils/logSanitize.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { describeValidationErrors, isRecord, SystemOneDecisionProvider, } from "./systemOneDecision.js";
-/**
- * LiteLLM echoes credentials back in its error texts, in more than one
- * wording: a masked key plus its hash on a rejected key, the whole key when it
- * does not look like a LiteLLM key, a key hash on a rate limit. None of it
- * belongs in an error message or a log, whatever the wording, so the
- * configured key, anything shaped like a LiteLLM key and any long hex run are
- * all removed.
- */
-function redactCredentials(message, apiKey) {
-    const withoutKey = apiKey
-        ? message.split(apiKey).join("[redacted]")
-        : message;
-    return withoutKey
-        .replace(/\.?\s*Received API Key\s*=[\s\S]*$/, "")
-        .replace(/\bsk-[A-Za-z0-9._-]+/g, "[redacted]")
-        .replace(/\b[0-9a-f]{32,}\b/gi, "[redacted]")
-        .trim();
-}
+import { describeValidationErrors, isRecord, redactCredentials, SystemOneDecisionProvider, } from "./systemOneDecision.js";
 /**
  * Normalise the two envelopes a Laya failure can arrive in.
  *

package/dist/providers/openaiChatCompletionsBase.js

@@ -873,7 +873,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             options.disableInternalFallback === true;
         // The native loop bypasses BaseProvider.executeGeneration, so the turn
         // budget has to be composed here or it stops existing for this provider.
-        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback);
+        return this.runGenerateWithModelFallback(() => this.withTurnTimeout({ ...options, tools: mergedTools }, this.getDescriptorGenerateMs(), (timedOptions) => this.executeNativeGenerate(timedOptions)), callerOwnsFallback, options);
     }
     async executeNativeGenerate(options) {
         const startTime = Date.now();

package/dist/providers/systemOneDecision.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { ProviderError } from "../types/index.js";
-import type { DecisionError, DecisionQuestion, DecisionRequest, DecisionResult, DecisionState, LanguageModel, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+import type { DecisionError, DecisionQuestion, DecisionRequest, DecisionResult, DecisionPreparedMedia, DecisionState, LanguageModel, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
 /**
  * Generous enough for a cold start (measured at 2.0–2.7s after idle on Jev)
  * while still bounded. Every internal caller is fail-open, so this only bites
@@ -16,6 +16,15 @@ export declare const asNumber: (v: unknown) => number | undefined;
  * request back — possibly the whole state — so it is never surfaced.
  */
 export declare function describeValidationErrors(detail: readonly unknown[]): string;
+/**
+ * A LiteLLM proxy echoes credentials back in its error texts, in more than one
+ * wording: a masked key plus its hash on a rejected key, the whole key when it
+ * does not look like a LiteLLM key, a key hash on a rate limit. None of it
+ * belongs in an error message or a log, whatever the wording, so the
+ * configured key, anything shaped like a LiteLLM key, any long hex run and any
+ * embedded `data:` URL are all removed.
+ */
+export declare function redactCredentials(message: string, apiKey: string): string;
 /**
  * The shared half of every "System One" decision provider — a model that takes
  * one `state` plus typed questions and returns one typed answer each, with no
@@ -52,7 +61,7 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
     protected missingConfigMessage(): string | undefined;
     protected abstract decisionEndpoint(): string;
     protected abstract decisionHeaders(): Record<string, string>;
-    protected abstract buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string): Record<string, unknown>;
+    protected abstract buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string, media?: DecisionPreparedMedia): Record<string, unknown>;
     protected abstract parseDecisionError(status: number, payload: unknown, requestId: string | undefined): DecisionError;
     protected abstract readRequestId(headers: Headers): string | undefined;
     /**
@@ -87,6 +96,16 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      * which returns null instead.
      */
     decide(request: DecisionRequest): Promise<DecisionResult>;
+    /**
+     * Turn the request's images and video into data URLs, or refuse it. Refused
+     * as a non-retryable `invalid_request`: resending the same media cannot help.
+     */
+    private prepareMedia;
+    /**
+     * The encoded body, not just the media, is what the server's size limit
+     * applies to.
+     */
+    private assertWithinRequestBytes;
     /**
      * Refuse a request the model cannot read in full. An encoder cuts the state
      * off past its window without saying so, so without this a decision would