@jaypie/llm 1.2.28 → 1.2.31

package/dist/cjs/index.cjs

@@ -31,7 +31,7 @@ const FIRST_CLASS_PROVIDER = {
     // https://developers.openai.com/api/docs/models
     OPENAI: {
         DEFAULT: "gpt-5.4",
-        LARGE: "gpt-5.4",
+        LARGE: "gpt-5.5",
         SMALL: "gpt-5.4-mini",
         TINY: "gpt-5.4-nano",
     },
@@ -586,9 +586,7 @@ function jsonSchemaToOpenApi3(schema) {
             }
             result[key] = convertedProps;
         }
-        else if (key === "items" &&
-            typeof value === "object" &&
-            value !== null) {
+        else if (key === "items" && typeof value === "object" && value !== null) {
             result[key] = jsonSchemaToOpenApi3(value);
         }
         else {
@@ -986,8 +984,140 @@ function isTransientNetworkError(error) {
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+const STRUCTURED_OUTPUT_NON_PARSE_STOP_REASONS = new Set([
+    "refusal",
+    "max_tokens",
+]);
 // Regular expression to parse data URLs: data:mime/type;base64,data
 const DATA_URL_REGEX = /^data:([^;]+);base64,(.+)$/;
+// String formats accepted by Anthropic's structured-output grammar compiler.
+// Other formats are stripped (move to description) so the API does not 400.
+const SUPPORTED_STRING_FORMATS = new Set([
+    "date",
+    "date-time",
+    "duration",
+    "email",
+    "hostname",
+    "ipv4",
+    "ipv6",
+    "time",
+    "uri",
+    "uuid",
+]);
+// Top-level keywords stripped wholesale before sending: not part of the spec
+// the API enforces and the validator can reject them.
+const STRIPPED_TOP_LEVEL_KEYWORDS = new Set(["$schema", "$id"]);
+// Keywords Anthropic's structured-output grammar does not support. They are
+// removed from the schema and appended to `description` so the model still
+// sees the intent.
+const UNSUPPORTED_CONSTRAINT_KEYWORDS = new Set([
+    "exclusiveMaximum",
+    "exclusiveMinimum",
+    "maxItems",
+    "maxLength",
+    "maxProperties",
+    "maximum",
+    "minLength",
+    "minProperties",
+    "minimum",
+    "multipleOf",
+    "pattern",
+    "patternProperties",
+    "uniqueItems",
+]);
+/**
+ * Recursively transform a JSON Schema into the strict shape Anthropic's
+ * structured-output grammar accepts: object types must have
+ * `additionalProperties: false`, unsupported numeric/string/array
+ * constraints are appended to `description`, and unsupported string
+ * formats are stripped. Mirrors @anthropic-ai/sdk's `transformJSONSchema`
+ * but inline so we do not take a runtime dependency on the optional
+ * peer SDK.
+ */
+function sanitizeJsonSchemaForAnthropic(schema, isRoot = true) {
+    const result = {};
+    const carriedConstraints = [];
+    for (const [key, value] of Object.entries(schema)) {
+        if (isRoot && STRIPPED_TOP_LEVEL_KEYWORDS.has(key)) {
+            continue;
+        }
+        if (UNSUPPORTED_CONSTRAINT_KEYWORDS.has(key)) {
+            carriedConstraints.push(`${key}: ${JSON.stringify(value)}`);
+            continue;
+        }
+        if (key === "format" && typeof value === "string") {
+            if (SUPPORTED_STRING_FORMATS.has(value)) {
+                result[key] = value;
+            }
+            else {
+                carriedConstraints.push(`format: ${JSON.stringify(value)}`);
+            }
+            continue;
+        }
+        if (key === "minItems" && typeof value === "number") {
+            if (value === 0 || value === 1) {
+                result[key] = value;
+            }
+            else {
+                carriedConstraints.push(`minItems: ${value}`);
+            }
+            continue;
+        }
+        if (key === "properties" &&
+            value &&
+            typeof value === "object" &&
+            !Array.isArray(value)) {
+            const transformedProps = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                transformedProps[propName] = isJsonSchema(propSchema)
+                    ? sanitizeJsonSchemaForAnthropic(propSchema, false)
+                    : propSchema;
+            }
+            result[key] = transformedProps;
+            continue;
+        }
+        if ((key === "items" || key === "additionalItems" || key === "contains") &&
+            isJsonSchema(value)) {
+            result[key] = sanitizeJsonSchemaForAnthropic(value, false);
+            continue;
+        }
+        if ((key === "anyOf" || key === "oneOf" || key === "allOf") &&
+            Array.isArray(value)) {
+            const targetKey = key === "oneOf" ? "anyOf" : key;
+            result[targetKey] = value.map((entry) => isJsonSchema(entry)
+                ? sanitizeJsonSchemaForAnthropic(entry, false)
+                : entry);
+            continue;
+        }
+        if (key === "$defs" && value && typeof value === "object") {
+            const transformedDefs = {};
+            for (const [defName, defSchema] of Object.entries(value)) {
+                transformedDefs[defName] = isJsonSchema(defSchema)
+                    ? sanitizeJsonSchemaForAnthropic(defSchema, false)
+                    : defSchema;
+            }
+            result[key] = transformedDefs;
+            continue;
+        }
+        if (key === "additionalProperties") {
+            // Always force `false` on objects below; ignore caller-supplied value.
+            continue;
+        }
+        result[key] = value;
+    }
+    if (result.type === "object") {
+        result.additionalProperties = false;
+    }
+    if (carriedConstraints.length > 0) {
+        const existing = typeof result.description === "string" ? result.description : "";
+        const suffix = `{${carriedConstraints.join(", ")}}`;
+        result.description = existing ? `${existing}\n\n${suffix}` : suffix;
+    }
+    return result;
+}
+function isJsonSchema(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
  * Parse a data URL into its components
  */
@@ -1083,6 +1213,29 @@ function isTemperatureDeprecationError(error) {
     const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
     return messages.some((m) => m.toLowerCase().includes("temperature"));
 }
+/**
+ * Detect 400 errors that indicate the model itself does not support native
+ * structured outputs (`output_config.format`). Citations + structured output
+ * is also a 400 case but is a caller error rather than a model-capability
+ * gap, so we explicitly skip it to avoid masking the real problem under a
+ * tool-emulation retry. The deprecated-`output_format` 400 (API renamed the
+ * field) is also explicitly excluded — that's a code-path bug, not a model
+ * gap; it should propagate so we notice and fix it.
+ */
+function isStructuredOutputUnsupportedError$1(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const name = error?.constructor?.name;
+    if (name !== "BadRequestError" && err.status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    if (messages.some((m) => /citation/i.test(m)))
+        return false;
+    if (messages.some((m) => /deprecated/i.test(m)))
+        return false;
+    return messages.some((m) => /output_config|output_format|json[_ ]schema|structured/i.test(m));
+}
 //
 //
 // Main
@@ -1100,6 +1253,10 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Session-level cache of models observed to reject `temperature` at runtime.
         // Populated by executeRequest on 400 errors so repeat calls skip the param.
         this.runtimeNoTemperatureModels = new Set();
+        // Session-level cache of models observed to reject `output_format`. When a
+        // model is in this set, buildRequest engages the legacy fake-tool path
+        // instead of native structured output.
+        this.runtimeNoStructuredOutputModels = new Set();
     }
     rememberModelRejectsTemperature(model) {
         this.runtimeNoTemperatureModels.add(model);
@@ -1107,11 +1264,20 @@ class AnthropicAdapter extends BaseProviderAdapter {
     clearRuntimeNoTemperatureModels() {
         this.runtimeNoTemperatureModels.clear();
     }
+    rememberModelRejectsStructuredOutput(model) {
+        this.runtimeNoStructuredOutputModels.add(model);
+    }
+    clearRuntimeNoStructuredOutputModels() {
+        this.runtimeNoStructuredOutputModels.clear();
+    }
     supportsTemperature(model) {
         if (this.runtimeNoTemperatureModels.has(model))
             return false;
         return !MODELS_WITHOUT_TEMPERATURE.some((pattern) => pattern.test(model));
     }
+    supportsStructuredOutput(model) {
+        return !this.runtimeNoStructuredOutputModels.has(model);
+    }
     //
     // Request Building
     //
@@ -1179,8 +1345,22 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (request.system) {
             anthropicRequest.system = request.system;
         }
-        if (request.tools && request.tools.length > 0) {
-            anthropicRequest.tools = request.tools.map((tool) => ({
+        const useFallbackStructuredOutput = Boolean(request.format) &&
+            !this.supportsStructuredOutput(anthropicRequest.model);
+        const allTools = request.tools
+            ? [...request.tools]
+            : [];
+        if (useFallbackStructuredOutput && request.format) {
+            log$1.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
+            allTools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                description: "Output a structured JSON object, " +
+                    "use this before your final response to give structured outputs to the user",
+                parameters: request.format,
+            });
+        }
+        if (allTools.length > 0) {
+            anthropicRequest.tools = allTools.map((tool) => ({
                 name: tool.name,
                 description: tool.description,
                 input_schema: {
@@ -1189,10 +1369,19 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 },
                 type: "custom",
             }));
-            // Determine tool choice based on whether structured output is requested
-            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
-            anthropicRequest.tool_choice = {
-                type: hasStructuredOutput ? "any" : "auto",
+            anthropicRequest.tool_choice = useFallbackStructuredOutput
+                ? { type: "any" }
+                : { type: "auto" };
+        }
+        // Native structured output: send schema as `output_config.format`. The
+        // legacy tool-emulation path is engaged only as a runtime fallback for
+        // models the API has flagged as not supporting native structured output.
+        if (request.format && !useFallbackStructuredOutput) {
+            anthropicRequest.output_config = {
+                format: {
+                    type: "json_schema",
+                    schema: request.format,
+                },
             };
         }
         if (request.providerOptions) {
@@ -1209,8 +1398,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         return anthropicRequest;
     }
-    formatTools(toolkit, outputSchema) {
-        const tools = toolkit.tools.map((tool) => ({
+    formatTools(toolkit, 
+    // outputSchema is part of the interface contract but Anthropic now uses
+    // native `output_format` (set in buildRequest), so we no longer inject a
+    // synthetic structured-output tool here.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _outputSchema) {
+        return toolkit.tools.map((tool) => ({
             name: tool.name,
             description: tool.description,
             parameters: {
@@ -1218,16 +1412,6 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 type: "object",
             },
         }));
-        // Add structured output tool if schema is provided
-        if (outputSchema) {
-            tools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
-                description: "Output a structured JSON object, " +
-                    "use this before your final response to give structured outputs to the user",
-                parameters: outputSchema,
-            });
-        }
-        return tools;
     }
     formatOutputSchema(schema) {
         let jsonSchema;
@@ -1246,11 +1430,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 : naturalZodSchema(schema);
             jsonSchema = v4.z.toJSONSchema(zodSchema);
         }
-        // Remove $schema property (causes issues with validator)
-        if (jsonSchema.$schema) {
-            delete jsonSchema.$schema;
-        }
-        return jsonSchema;
+        return sanitizeJsonSchemaForAnthropic(jsonSchema);
     }
     //
     // API Execution
@@ -1258,8 +1438,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
     async executeRequest(client, request, signal) {
         const anthropic = client;
         const anthropicRequest = request;
+        const wantsStructuredOutput = Boolean(anthropicRequest.output_config);
         try {
-            return (await anthropic.messages.create(anthropicRequest, signal ? { signal } : undefined));
+            const response = (await anthropic.messages.create(anthropicRequest, signal ? { signal } : undefined));
+            if (wantsStructuredOutput) {
+                response.__jaypieStructuredOutput = true;
+            }
+            return response;
         }
         catch (error) {
             if (signal?.aborted)
@@ -1270,13 +1455,53 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 this.rememberModelRejectsTemperature(anthropicRequest.model);
                 const retryRequest = { ...anthropicRequest };
                 delete retryRequest.temperature;
-                return (await anthropic.messages.create(retryRequest, signal ? { signal } : undefined));
+                const response = (await anthropic.messages.create(retryRequest, signal ? { signal } : undefined));
+                if (wantsStructuredOutput) {
+                    response.__jaypieStructuredOutput = true;
+                }
+                return response;
+            }
+            // If the model rejected native structured output, cache it and retry
+            // via the legacy fake-tool emulation path.
+            if (wantsStructuredOutput && isStructuredOutputUnsupportedError$1(error)) {
+                const model = anthropicRequest.model;
+                this.rememberModelRejectsStructuredOutput(model);
+                log$1.warn(`[AnthropicAdapter] Model ${model} rejected native output_config; falling back to legacy structured_output tool emulation.`);
+                const fallbackRequest = this.toFallbackStructuredOutputRequest(anthropicRequest);
+                return (await anthropic.messages.create(fallbackRequest, signal ? { signal } : undefined));
             }
             throw error;
         }
     }
+    /**
+     * Rebuild a structured-output request without `output_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native `output_config.format`.
+     */
+    toFallbackStructuredOutputRequest(request) {
+        const { output_config, ...rest } = request;
+        if (!output_config)
+            return request;
+        const fallbackRequest = { ...rest };
+        const fakeTool = {
+            name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+            description: "Output a structured JSON object, " +
+                "use this before your final response to give structured outputs to the user",
+            input_schema: {
+                ...output_config.format.schema,
+                type: "object",
+            },
+            type: "custom",
+        };
+        fallbackRequest.tools = [...(fallbackRequest.tools ?? []), fakeTool];
+        fallbackRequest.tool_choice = { type: "any" };
+        return fallbackRequest;
+    }
     async *executeStreamRequest(client, request, signal) {
         const anthropic = client;
+        // Preserve `output_config` when passing through to the SDK by typing
+        // through the local extension instead of the upstream
+        // MessageCreateParams shape.
         let streamRequest = {
             ...request,
             stream: true,
@@ -1536,13 +1761,39 @@ class AnthropicAdapter extends BaseProviderAdapter {
     }
     hasStructuredOutput(response) {
         const anthropicResponse = response;
-        // Check if the last content block is a tool_use with structured_output
+        // Native path: executeRequest annotates the response when we sent
+        // `output_format`, so we can detect intent statelessly.
+        if (anthropicResponse.__jaypieStructuredOutput) {
+            return this.extractStructuredOutput(response) !== undefined;
+        }
+        // Fallback path: legacy fake-tool emulation, kept for models that the
+        // runtime has cached as not supporting `output_format`.
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         return (lastBlock?.type === "tool_use" &&
             lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
     }
     extractStructuredOutput(response) {
         const anthropicResponse = response;
+        if (anthropicResponse.__jaypieStructuredOutput) {
+            // Refusal and truncation are explicit non-JSON outcomes per Anthropic
+            // structured-outputs docs — surface the text upstream instead of
+            // forcing a JSON.parse on what is not JSON.
+            if (anthropicResponse.stop_reason &&
+                STRUCTURED_OUTPUT_NON_PARSE_STOP_REASONS.has(anthropicResponse.stop_reason)) {
+                return undefined;
+            }
+            const textBlock = anthropicResponse.content.find((block) => block.type === "text");
+            if (!textBlock)
+                return undefined;
+            try {
+                const parsed = JSON.parse(textBlock.text);
+                return parsed;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        // Fallback path: legacy fake-tool emulation
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         if (lastBlock?.type === "tool_use" &&
             lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
@@ -1571,6 +1822,26 @@ const anthropicAdapter = new AnthropicAdapter();
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
+// Gemini 3 family supports combining tools (function calling) with native
+// structured output via `responseJsonSchema`. Earlier Gemini families
+// (including 2.5 thinking) do not support the combo and fall back to the
+// legacy `structured_output` fake-tool emulation.
+const GEMINI_3_PATTERN = /^gemini-3/;
+/**
+ * Detect 4xx errors that indicate the model itself does not support the
+ * `responseJsonSchema` + tools combo. Triggers the runtime fallback to the
+ * fake-tool emulation path. Other 400s propagate.
+ */
+function isStructuredOutputComboUnsupportedError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.code;
+    if (status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => /response[_ ]?json[_ ]?schema|response[_ ]?schema|response[_ ]?mime|function[_ ]?call|tools/i.test(m));
+}
 // Gemini uses HTTP status codes for error classification
 // Documented at: https://ai.google.dev/api/rest/v1beta/Status
 const RETRYABLE_STATUS_CODES$1 = [
@@ -1603,6 +1874,21 @@ class GeminiAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.GEMINI.NAME;
         this.defaultModel = PROVIDER.GEMINI.MODEL.DEFAULT;
+        // Session-level cache of Gemini 3 models observed to reject the native
+        // `responseJsonSchema` + tools combo. When a model is in this set,
+        // buildRequest engages the legacy fake-tool path instead.
+        this.runtimeNoStructuredOutputComboModels = new Set();
+    }
+    rememberModelRejectsStructuredOutputCombo(model) {
+        this.runtimeNoStructuredOutputComboModels.add(model);
+    }
+    clearRuntimeNoStructuredOutputComboModels() {
+        this.runtimeNoStructuredOutputComboModels.clear();
+    }
+    supportsStructuredOutputCombo(model) {
+        if (this.runtimeNoStructuredOutputComboModels.has(model))
+            return false;
+        return GEMINI_3_PATTERN.test(model);
     }
     //
     // Request Building
@@ -1631,9 +1917,27 @@ class GeminiAdapter extends BaseProviderAdapter {
                 }
             }
         }
-        // Add tools if provided
-        if (request.tools && request.tools.length > 0) {
-            const functionDeclarations = request.tools.map((tool) => ({
+        const hasUserTools = !!(request.tools && request.tools.length > 0);
+        const useNativeCombo = Boolean(request.format) &&
+            hasUserTools &&
+            this.supportsStructuredOutputCombo(geminiRequest.model);
+        // When tools+format are combined and the model does not support the native
+        // combo, inject the legacy `structured_output` fake tool here so the model
+        // is forced to call it before its final answer.
+        const allTools = request.tools
+            ? [...request.tools]
+            : [];
+        if (request.format && hasUserTools && !useNativeCombo) {
+            log$1.warn(`[GeminiAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+            allTools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
+                description: "Output a structured JSON object, " +
+                    "use this before your final response to give structured outputs to the user",
+                parameters: request.format,
+            });
+        }
+        if (allTools.length > 0) {
+            const functionDeclarations = allTools.map((tool) => ({
                 name: tool.name,
                 description: tool.description,
                 parameters: tool.parameters,
@@ -1643,11 +1947,13 @@ class GeminiAdapter extends BaseProviderAdapter {
                 tools: [{ functionDeclarations }],
             };
         }
-        // Add structured output format if provided (but NOT when tools are present)
-        // Gemini doesn't support combining function calling with responseMimeType: 'application/json'
-        // When tools are present, structured output is handled via the structured_output tool
-        if (request.format && !(request.tools && request.tools.length > 0)) {
-            const useJsonSchema = request.providerOptions?.useJsonSchema === true;
+        // Native structured output: send schema as `responseJsonSchema`
+        // (or `responseSchema` for Gemini 2.5+ no-tools path). The legacy
+        // fake-tool emulation only runs when format+tools is combined on a model
+        // that doesn't support the native combo.
+        const wantsNativeStructured = Boolean(request.format) && (!hasUserTools || useNativeCombo);
+        if (wantsNativeStructured) {
+            const useJsonSchema = useNativeCombo || request.providerOptions?.useJsonSchema === true;
             if (useJsonSchema) {
                 geminiRequest.config = {
                     ...geminiRequest.config,
@@ -1663,11 +1969,11 @@ class GeminiAdapter extends BaseProviderAdapter {
                 };
             }
         }
-        // When format is specified with tools, add instruction to use structured_output tool
-        if (request.format && request.tools && request.tools.length > 0) {
+        // Legacy fake-tool path needs a system-prompt nudge so the model actually
+        // calls the synthetic tool before its final answer.
+        if (request.format && hasUserTools && !useNativeCombo) {
             const structuredOutputInstruction = "IMPORTANT: Before providing your final response, you MUST use the structured_output tool " +
                 "to output your answer in the required JSON format.";
-            // Add to system instruction if it exists, otherwise create one
             const existingSystem = geminiRequest.config?.systemInstruction || "";
             geminiRequest.config = {
                 ...geminiRequest.config,
@@ -1692,8 +1998,14 @@ class GeminiAdapter extends BaseProviderAdapter {
         }
         return geminiRequest;
     }
-    formatTools(toolkit, outputSchema) {
-        const tools = toolkit.tools.map((tool) => ({
+    formatTools(toolkit, 
+    // outputSchema is part of the interface contract but Gemini now handles
+    // structured output via `responseJsonSchema`/`responseSchema` (or the
+    // legacy fake-tool injected in buildRequest as a fallback). We no longer
+    // inject a synthetic structured-output tool here.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _outputSchema) {
+        return toolkit.tools.map((tool) => ({
             name: tool.name,
             description: tool.description,
             parameters: {
@@ -1701,16 +2013,6 @@ class GeminiAdapter extends BaseProviderAdapter {
                 type: "object",
             },
         }));
-        // Add structured output tool if schema is provided
-        if (outputSchema) {
-            tools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
-                description: "Output a structured JSON object, " +
-                    "use this before your final response to give structured outputs to the user",
-                parameters: outputSchema,
-            });
-        }
-        return tools;
     }
     formatOutputSchema(schema) {
         let jsonSchema;
@@ -1737,6 +2039,8 @@ class GeminiAdapter extends BaseProviderAdapter {
     async executeRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
+        const wantsNativeCombo = !!geminiRequest.config?.responseJsonSchema &&
+            !!geminiRequest.config?.tools;
         try {
             // Cast config to any to bypass strict type checking between our internal types
             // and the SDK's types. The SDK will validate at runtime.
@@ -1750,9 +2054,56 @@ class GeminiAdapter extends BaseProviderAdapter {
         catch (error) {
             if (signal?.aborted)
                 return undefined;
+            // If the model rejected the native responseJsonSchema + tools combo,
+            // cache it and retry with the legacy fake-tool emulation path.
+            if (wantsNativeCombo && isStructuredOutputComboUnsupportedError(error)) {
+                const model = geminiRequest.model;
+                this.rememberModelRejectsStructuredOutputCombo(model);
+                log$1.warn(`[GeminiAdapter] Model ${model} rejected native responseJsonSchema + tools combo; falling back to legacy structured_output tool emulation.`);
+                const fallbackRequest = this.toFallbackStructuredOutputRequest(geminiRequest);
+                const response = await genAI.models.generateContent({
+                    model: fallbackRequest.model,
+                    contents: fallbackRequest.contents,
+                    config: fallbackRequest.config,
+                });
+                return response;
+            }
             throw error;
         }
     }
+    /**
+     * Rebuild a Gemini 3 native-combo request without `responseJsonSchema`/
+     * `responseMimeType`, swapping in the legacy fake-tool emulation. Used as
+     * a runtime fallback when a Gemini 3 model rejects the combo.
+     */
+    toFallbackStructuredOutputRequest(request) {
+        if (!request.config?.responseJsonSchema)
+            return request;
+        const schema = request.config.responseJsonSchema;
+        const newConfig = { ...request.config };
+        delete newConfig.responseJsonSchema;
+        delete newConfig.responseMimeType;
+        const fakeTool = {
+            name: STRUCTURED_OUTPUT_TOOL_NAME$1,
+            description: "Output a structured JSON object, " +
+                "use this before your final response to give structured outputs to the user",
+            parameters: schema,
+        };
+        const existingDeclarations = newConfig.tools?.[0]?.functionDeclarations ?? [];
+        newConfig.tools = [
+            { functionDeclarations: [...existingDeclarations, fakeTool] },
+        ];
+        const structuredOutputInstruction = "IMPORTANT: Before providing your final response, you MUST use the structured_output tool " +
+            "to output your answer in the required JSON format.";
+        const existingSystem = newConfig.systemInstruction || "";
+        newConfig.systemInstruction = existingSystem
+            ? `${existingSystem}\n\n${structuredOutputInstruction}`
+            : structuredOutputInstruction;
+        return {
+            ...request,
+            config: newConfig,
+        };
+    }
     async *executeStreamRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
@@ -2753,6 +3104,23 @@ const openAiAdapter = new OpenAiAdapter();
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+const STRUCTURED_OUTPUT_SCHEMA_NAME = "response";
+/**
+ * Detect 4xx errors that indicate the model itself does not support
+ * `response_format: json_schema`. Mirrors the Anthropic pattern: we only
+ * trigger the fake-tool fallback when the failure is plausibly a capability
+ * gap, not a generic 400.
+ */
+function isStructuredOutputUnsupportedError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.statusCode;
+    if (status !== 400 && status !== 422)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => /response_format|json[_ ]schema|structured[_ ]output|require[_ ]parameters/i.test(m));
+}
 /**
  * Convert standardized content items to OpenRouter format
  * Note: OpenRouter does not support native file/image uploads.
@@ -2791,6 +3159,32 @@ function convertContentToOpenRouter(content) {
 // OpenRouter SDK error types based on HTTP status codes
 const RETRYABLE_STATUS_CODES = [408, 500, 502, 503, 524, 529];
 const RATE_LIMIT_STATUS_CODE = 429;
+/**
+ * Walk the JSON schema and force `additionalProperties: false` on every
+ * object node. Required by the OpenAI-style json_schema response_format
+ * (which OpenRouter accepts) when `strict: true`.
+ */
+function enforceAdditionalPropertiesFalse(schema) {
+    const stack = [schema];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === "object") {
+            node.additionalProperties = false;
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                        stack.push(entry);
+                    }
+                }
+            }
+            else if (value && typeof value === "object") {
+                stack.push(value);
+            }
+        }
+    }
+}
 //
 //
 // Main
@@ -2806,6 +3200,19 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.OPENROUTER.NAME;
         this.defaultModel = PROVIDER.OPENROUTER.MODEL.DEFAULT;
+        // Session-level cache of models observed to reject native
+        // `response_format: json_schema`. When a model is in this set, buildRequest
+        // engages the legacy fake-tool path instead of native structured output.
+        this.runtimeNoStructuredOutputModels = new Set();
+    }
+    rememberModelRejectsStructuredOutput(model) {
+        this.runtimeNoStructuredOutputModels.add(model);
+    }
+    clearRuntimeNoStructuredOutputModels() {
+        this.runtimeNoStructuredOutputModels.clear();
+    }
+    supportsStructuredOutput(model) {
+        return !this.runtimeNoStructuredOutputModels.has(model);
     }
     //
     // Request Building
@@ -2827,8 +3234,23 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         if (request.user) {
             openRouterRequest.user = request.user;
         }
-        if (request.tools && request.tools.length > 0) {
-            openRouterRequest.tools = request.tools.map((tool) => ({
+        const useFallbackStructuredOutput = Boolean(request.format) &&
+            !this.supportsStructuredOutput(openRouterRequest.model);
+        const allTools = request.tools
+            ? [...request.tools]
+            : [];
+        if (useFallbackStructuredOutput && request.format) {
+            log$1.log.warn(`[OpenRouterAdapter] Using legacy structured_output tool fallback for model ${openRouterRequest.model}; native response_format previously rejected for this model.`);
+            allTools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: request.format,
+            });
+        }
+        if (allTools.length > 0) {
+            openRouterRequest.tools = allTools.map((tool) => ({
                 type: "function",
                 function: {
                     name: tool.name,
@@ -2840,6 +3262,19 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             // The structured_output tool prompt already emphasizes it must be called
             openRouterRequest.tool_choice = "auto";
         }
+        // Native structured output: send schema as `response_format`. The legacy
+        // tool-emulation path is engaged only as a runtime fallback for models the
+        // API has flagged as not supporting native json_schema.
+        if (request.format && !useFallbackStructuredOutput) {
+            openRouterRequest.response_format = {
+                type: "json_schema",
+                json_schema: {
+                    name: STRUCTURED_OUTPUT_SCHEMA_NAME,
+                    schema: request.format,
+                    strict: true,
+                },
+            };
+        }
         if (request.providerOptions) {
             Object.assign(openRouterRequest, request.providerOptions);
         }
@@ -2850,24 +3285,18 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         }
         return openRouterRequest;
     }
-    formatTools(toolkit, outputSchema) {
-        const tools = toolkit.tools.map((tool) => ({
+    formatTools(toolkit, 
+    // outputSchema is part of the interface contract but OpenRouter now uses
+    // native `response_format` (set in buildRequest), so we no longer inject a
+    // synthetic structured-output tool here. The legacy fake-tool injection
+    // happens in buildRequest only as a runtime fallback.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _outputSchema) {
+        return toolkit.tools.map((tool) => ({
             name: tool.name,
             description: tool.description,
             parameters: tool.parameters,
         }));
-        // Add structured output tool if schema is provided
-        // (OpenRouter doesn't have native structured output like OpenAI, so use tool approach)
-        if (outputSchema) {
-            tools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME,
-                description: "REQUIRED: You MUST call this tool to provide your final response. " +
-                    "After gathering all necessary information (including results from other tools), " +
-                    "call this tool with the structured data to complete the request.",
-                parameters: outputSchema,
-            });
-        }
-        return tools;
     }
     formatOutputSchema(schema) {
         let jsonSchema;
@@ -2890,6 +3319,9 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         if (jsonSchema.$schema) {
             delete jsonSchema.$schema;
         }
+        // OpenRouter (and most backends behind it) require additionalProperties:
+        // false on every object when using strict json_schema response_format.
+        enforceAdditionalPropertiesFalse(jsonSchema);
         return jsonSchema;
     }
     //
@@ -2898,34 +3330,99 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     async executeRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
+        const wantsStructuredOutput = Boolean(openRouterRequest.response_format);
         try {
-            const response = await openRouter.chat.send({
-                model: openRouterRequest.model,
-                messages: openRouterRequest.messages,
-                tools: openRouterRequest.tools,
-                toolChoice: openRouterRequest.tool_choice,
-                user: openRouterRequest.user,
-            }, signal ? { signal } : undefined);
+            const response = (await openRouter.chat.send(this.toSdkChatParams(openRouterRequest), signal ? { signal } : undefined));
+            if (wantsStructuredOutput) {
+                response.__jaypieStructuredOutput = true;
+            }
             return response;
         }
         catch (error) {
             if (signal?.aborted)
                 return undefined;
+            // If the model rejected `response_format`, cache it and retry with the
+            // legacy fake-tool emulation path.
+            if (wantsStructuredOutput && isStructuredOutputUnsupportedError(error)) {
+                const model = openRouterRequest.model;
+                this.rememberModelRejectsStructuredOutput(model);
+                log$1.log.warn(`[OpenRouterAdapter] Model ${model} rejected native response_format; falling back to legacy structured_output tool emulation.`);
+                const fallbackRequest = this.toFallbackStructuredOutputRequest(openRouterRequest);
+                return (await openRouter.chat.send(this.toSdkChatParams(fallbackRequest), signal ? { signal } : undefined));
+            }
             throw error;
         }
     }
-    async *executeStreamRequest(client, request, signal) {
-        const openRouter = client;
-        const openRouterRequest = request;
-        // Use chat.send with stream: true for streaming responses
-        const stream = await openRouter.chat.send({
+    /**
+     * Translate our internal snake_case `OpenRouterRequest` into the SDK's
+     * camelCase shape, forwarding only the fields we care about (the SDK
+     * silently strips unknown fields).
+     */
+    toSdkChatParams(openRouterRequest) {
+        const params = {
             model: openRouterRequest.model,
             messages: openRouterRequest.messages,
             tools: openRouterRequest.tools,
             toolChoice: openRouterRequest.tool_choice,
             user: openRouterRequest.user,
+        };
+        if (openRouterRequest.response_format) {
+            const format = openRouterRequest.response_format;
+            if (format.type === "json_schema") {
+                params.responseFormat = {
+                    type: "json_schema",
+                    jsonSchema: format.json_schema,
+                };
+            }
+            else {
+                params.responseFormat = format;
+            }
+        }
+        const temperature = openRouterRequest.temperature;
+        if (temperature !== undefined) {
+            params.temperature = temperature;
+        }
+        return params;
+    }
+    /**
+     * Rebuild a structured-output request without `response_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native json_schema.
+     */
+    toFallbackStructuredOutputRequest(request) {
+        if (!request.response_format ||
+            request.response_format.type !== "json_schema") {
+            return request;
+        }
+        const { response_format, ...rest } = request;
+        const fallbackRequest = { ...rest };
+        const schema = response_format.json_schema.schema;
+        const fakeTool = {
+            type: "function",
+            function: {
+                name: STRUCTURED_OUTPUT_TOOL_NAME,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: schema,
+            },
+        };
+        fallbackRequest.tools = [...(fallbackRequest.tools ?? []), fakeTool];
+        fallbackRequest.tool_choice = "auto";
+        return fallbackRequest;
+    }
+    async *executeStreamRequest(client, request, signal) {
+        const openRouter = client;
+        const openRouterRequest = request;
+        // Use chat.send with stream: true for streaming responses.
+        // Cast the result to AsyncIterable: when stream: true, the SDK returns a
+        // stream we can iterate, but the typed result is the union with the
+        // non-stream response.
+        const streamParams = {
+            ...this.toSdkChatParams(openRouterRequest),
             stream: true,
-        }, signal ? { signal } : undefined);
+        };
+        const stream = (await openRouter.chat.send(streamParams, signal ? { signal } : undefined));
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -3204,6 +3701,13 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     }
     hasStructuredOutput(response) {
         const openRouterResponse = response;
+        // Native path: executeRequest annotates the response when we sent
+        // `response_format`, so we can detect intent statelessly.
+        if (openRouterResponse.__jaypieStructuredOutput) {
+            return this.extractStructuredOutput(response) !== undefined;
+        }
+        // Fallback path: legacy fake-tool emulation, kept for models that the
+        // runtime has cached as not supporting native `response_format`.
         const choice = openRouterResponse.choices[0];
         // SDK returns camelCase (toolCalls)
         if (!choice?.message?.toolCalls?.length) {
@@ -3215,6 +3719,20 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     }
     extractStructuredOutput(response) {
         const openRouterResponse = response;
+        if (openRouterResponse.__jaypieStructuredOutput) {
+            const choice = openRouterResponse.choices[0];
+            const content = choice?.message?.content;
+            if (typeof content !== "string" || content.length === 0) {
+                return undefined;
+            }
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        // Fallback path: legacy fake-tool emulation
         const choice = openRouterResponse.choices[0];
         // SDK returns camelCase (toolCalls)
         if (!choice?.message?.toolCalls?.length) {
@@ -3340,10 +3858,29 @@ class OpenRouterAdapter extends BaseProviderAdapter {
 // Export singleton instance
 const openRouterAdapter = new OpenRouterAdapter();
 
+/**
+ * Error-message substrings that indicate a transient xAI media-ingest flake.
+ * The xAI ingest service enters a bad state after ~12 consecutive file-bearing
+ * calls and rejects subsequent requests with HTTP 400. The condition is
+ * self-clearing, so these errors should be retried with backoff rather than
+ * surfaced as unrecoverable.
+ *
+ * See: github.com/finlaysonstudio/jaypie issue #301
+ */
+const TRANSIENT_INGEST_MESSAGE_PATTERNS = [
+    "failed to ingest inline file bytes",
+];
+function isTransientIngestError(error) {
+    if (!(error instanceof openai.BadRequestError))
+        return false;
+    const message = (error.message ?? "").toLowerCase();
+    return TRANSIENT_INGEST_MESSAGE_PATTERNS.some((pattern) => message.includes(pattern));
+}
 /**
  * XaiAdapter extends OpenAiAdapter since xAI (Grok) uses an OpenAI-compatible API.
- * Only the name and default model are overridden; all request building, response parsing,
- * error classification, tool handling, and streaming are inherited.
+ * Name, default model, and transient-ingest-error detection are overridden;
+ * all request building, response parsing, tool handling, and streaming are
+ * inherited.
  */
 class XaiAdapter extends OpenAiAdapter {
     constructor() {
@@ -3353,6 +3890,16 @@ class XaiAdapter extends OpenAiAdapter {
         // @ts-expect-error Narrowing override: xAI default model differs from parent's literal
         this.defaultModel = PROVIDER.XAI.MODEL.DEFAULT;
     }
+    classifyError(error) {
+        if (isTransientIngestError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        return super.classifyError(error);
+    }
 }
 // Export singleton instance
 const xaiAdapter = new XaiAdapter();
@@ -5206,55 +5753,50 @@ async function createTextCompletion$1(client, messages, model, systemMessage) {
     log$1.log.trace(`Assistant reply: ${text.length} characters`);
     return text;
 }
-// Structured output completion
+// Structured output completion using Anthropic's native `output_config.format`
+// field. Returns a JsonObject parsed and validated against the caller's
+// Zod schema.
 async function createStructuredCompletion$1(client, messages, model, responseSchema, systemMessage) {
-    log$1.log.trace("Using structured output");
-    // Get the JSON schema for the response
+    log$1.log.trace("Using native structured output");
     const schema = responseSchema instanceof v4.z.ZodType
         ? responseSchema
         : naturalZodSchema(responseSchema);
-    // Set system message with JSON instructions
-    const defaultSystemPrompt = "You will be responding with structured JSON data. " +
-        "Format your entire response as a valid JSON object with the following structure: " +
-        JSON.stringify(v4.z.toJSONSchema(schema));
-    const systemPrompt = systemMessage || defaultSystemPrompt;
-    try {
-        // Use standard Anthropic API to get response
-        const params = {
-            model,
-            messages,
-            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
-            system: systemPrompt,
-        };
-        const response = await client.messages.create(params);
-        // Extract text from response
-        const firstContent = response.content[0];
-        const responseText = firstContent && "text" in firstContent ? firstContent.text : "";
-        // Find JSON in response
-        const jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
-            responseText.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            try {
-                // Parse the JSON response
-                const jsonStr = jsonMatch[1] || jsonMatch[0];
-                const result = JSON.parse(jsonStr);
-                if (!schema.parse(result)) {
-                    throw new Error(`JSON response from Anthropic does not match schema: ${responseText}`);
-                }
-                log$1.log.trace("Received structured response", { result });
-                return result;
-            }
-            catch {
-                throw new Error(`Failed to parse JSON response from Anthropic: ${responseText}`);
-            }
-        }
-        // If we can't extract JSON
+    const jsonSchema = v4.z.toJSONSchema(schema);
+    const params = {
+        model,
+        messages,
+        max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+        output_config: {
+            format: { type: "json_schema", schema: jsonSchema },
+        },
+    };
+    if (systemMessage) {
+        params.system = systemMessage;
+    }
+    const response = (await client.messages.create(params));
+    if (response.stop_reason === "refusal") {
+        throw new Error("Anthropic refused the structured-output request (stop_reason=refusal)");
+    }
+    if (response.stop_reason === "max_tokens") {
+        throw new Error("Anthropic structured-output response was truncated (stop_reason=max_tokens); increase max_tokens");
+    }
+    const textBlock = response.content.find((block) => block.type === "text");
+    if (!textBlock) {
         throw new Error("Failed to parse structured response from Anthropic");
     }
-    catch (error) {
-        log$1.log.error("Error creating structured completion", { error });
-        throw error;
+    let parsed;
+    try {
+        parsed = JSON.parse(textBlock.text);
+    }
+    catch {
+        throw new Error("Failed to parse structured response from Anthropic: " + textBlock.text);
+    }
+    const validation = schema.safeParse(parsed);
+    if (!validation.success) {
+        throw new Error(`JSON response from Anthropic does not match schema: ${textBlock.text}`);
     }
+    log$1.log.trace("Received structured response", { result: validation.data });
+    return validation.data;
 }
 
 // Maps Jaypie roles to Anthropic roles