@jaypie/llm 1.3.0 → 1.3.1

package/dist/cjs/index.cjs

@@ -1,45 +1,105 @@
 'use strict';
 
 var errors = require('@jaypie/errors');
-var log$2 = require('@jaypie/logger');
+var log$1 = require('@jaypie/logger');
 var v4 = require('zod/v4');
 var kit = require('@jaypie/kit');
 var RandomLib = require('random');
 var openai = require('openai');
 var zod = require('openai/helpers/zod');
+var module$1 = require('module');
+var url = require('url');
 var pdfLib = require('pdf-lib');
 var promises = require('fs/promises');
 var path = require('path');
 var aws = require('@jaypie/aws');
 var openmeteo = require('openmeteo');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 const FIRST_CLASS_PROVIDER = {
+    // https://docs.anthropic.com/en/docs/about-claude/models/overview
     ANTHROPIC: {
-        DEFAULT: "claude-sonnet-4-5",
-        LARGE: "claude-opus-4-5",
-        SMALL: "claude-sonnet-4-5",
+        DEFAULT: "claude-sonnet-4-6",
+        LARGE: "claude-opus-4-8",
+        SMALL: "claude-sonnet-4-6",
         TINY: "claude-haiku-4-5",
     },
-    GEMINI: {
-        DEFAULT: "gemini-3-pro-preview",
-        LARGE: "gemini-3-pro-preview",
-        SMALL: "gemini-3-flash-preview",
-        TINY: "gemini-3-flash-preview",
+    // https://ai.google.dev/gemini-api/docs/models
+    GOOGLE: {
+        DEFAULT: "gemini-3.1-pro-preview",
+        LARGE: "gemini-3.1-pro-preview",
+        SMALL: "gemini-3.5-flash",
+        TINY: "gemini-3.1-flash-lite",
     },
+    // https://developers.openai.com/api/docs/models
     OPENAI: {
-        DEFAULT: "gpt-5.2",
-        LARGE: "gpt-5.2-pro",
-        SMALL: "gpt-5-mini",
-        TINY: "gpt-5-nano",
+        DEFAULT: "gpt-5.4",
+        LARGE: "gpt-5.5",
+        SMALL: "gpt-5.4-mini",
+        TINY: "gpt-5.4-nano",
     },
-    OPENROUTER: {
-        DEFAULT: "z-ai/glm-4.7",
-        LARGE: "z-ai/glm-4.7",
-        SMALL: "z-ai/glm-4.7",
-        TINY: "z-ai/glm-4.7",
+    // https://docs.x.ai/developers/models
+    XAI: {
+        DEFAULT: "grok-latest",
+        LARGE: "grok-4.3-latest",
+        SMALL: "grok-4-1-fast-reasoning",
+        TINY: "grok-4-1-fast-non-reasoning",
+    },
+};
+const MODEL = {
+    // Anthropic
+    OPUS: "claude-opus-4-8",
+    SONNET: "claude-sonnet-4-6",
+    HAIKU: "claude-haiku-4-5",
+    FABLE: "claude-fable-5",
+    MYTHOS: "claude-mythos-5",
+    // Google
+    GEMINI_FLASH: "gemini-3.5-flash",
+    GEMINI_FLASH_LITE: "gemini-3.1-flash-lite",
+    GEMINI_PRO: "gemini-3.1-pro-preview",
+    // OpenAI
+    GPT: "gpt-5.5",
+    GPT_MINI: "gpt-5.4-mini",
+    GPT_NANO: "gpt-5.4-nano",
+    // xAI
+    GROK: "grok-latest",
+};
+const GOOGLE_PROVIDER = {
+    // https://ai.google.dev/gemini-api/docs/models
+    MODEL: {
+        DEFAULT: FIRST_CLASS_PROVIDER.GOOGLE.DEFAULT,
+        LARGE: FIRST_CLASS_PROVIDER.GOOGLE.LARGE,
+        SMALL: FIRST_CLASS_PROVIDER.GOOGLE.SMALL,
+        TINY: FIRST_CLASS_PROVIDER.GOOGLE.TINY,
+    },
+    MODEL_MATCH_WORDS: ["gemini", "google"],
+    NAME: "google",
+    ROLE: {
+        MODEL: "model",
+        USER: "user",
     },
 };
 const PROVIDER = {
+    // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+    BEDROCK: {
+        MODEL: {
+            DEFAULT: "amazon.nova-lite-v1:0",
+            LARGE: "amazon.nova-pro-v1:0",
+            SMALL: "amazon.nova-lite-v1:0",
+            TINY: "amazon.nova-micro-v1:0",
+        },
+        MODEL_MATCH_WORDS: [
+            "amazon.nova",
+            "amazon.titan",
+            "anthropic.claude",
+            "cohere.command",
+            "meta.llama",
+            "mistral.mistral",
+            "ai21.",
+        ],
+        NAME: "bedrock",
+        REGION: "AWS_REGION",
+    },
     ANTHROPIC: {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MAX_TOKENS: {
@@ -72,21 +132,9 @@ const PROVIDER = {
             SCHEMA_VERSION: "v2",
         },
     },
-    GEMINI: {
-        // https://ai.google.dev/gemini-api/docs/models
-        MODEL: {
-            DEFAULT: FIRST_CLASS_PROVIDER.GEMINI.DEFAULT,
-            LARGE: FIRST_CLASS_PROVIDER.GEMINI.LARGE,
-            SMALL: FIRST_CLASS_PROVIDER.GEMINI.SMALL,
-            TINY: FIRST_CLASS_PROVIDER.GEMINI.TINY,
-        },
-        MODEL_MATCH_WORDS: ["gemini", "google"],
-        NAME: "gemini",
-        ROLE: {
-            MODEL: "model",
-            USER: "user",
-        },
-    },
+    /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
+    GEMINI: GOOGLE_PROVIDER,
+    GOOGLE: GOOGLE_PROVIDER,
     OPENAI: {
         // https://platform.openai.com/docs/models
         MODEL: {
@@ -99,15 +147,11 @@ const PROVIDER = {
         NAME: "openai",
     },
     OPENROUTER: {
-        // https://openrouter.ai/models
-        // OpenRouter provides access to hundreds of models from various providers
-        // The model format is: provider/model-name (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
         MODEL: {
-            // Default uses env var OPENROUTER_MODEL if set, otherwise a reasonable default
-            DEFAULT: FIRST_CLASS_PROVIDER.OPENROUTER.DEFAULT,
-            LARGE: FIRST_CLASS_PROVIDER.OPENROUTER.LARGE,
-            SMALL: FIRST_CLASS_PROVIDER.OPENROUTER.SMALL,
-            TINY: FIRST_CLASS_PROVIDER.OPENROUTER.TINY,
+            DEFAULT: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.DEFAULT}`,
+            LARGE: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.LARGE}`,
+            SMALL: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.SMALL}`,
+            TINY: `anthropic/${FIRST_CLASS_PROVIDER.ANTHROPIC.TINY}`,
         },
         MODEL_MATCH_WORDS: ["openrouter"],
         NAME: "openrouter",
@@ -118,6 +162,19 @@ const PROVIDER = {
             USER: "user",
         },
     },
+    XAI: {
+        // https://docs.x.ai/docs/models
+        API_KEY: "XAI_API_KEY",
+        BASE_URL: "https://api.x.ai/v1",
+        MODEL: {
+            DEFAULT: FIRST_CLASS_PROVIDER.XAI.DEFAULT,
+            LARGE: FIRST_CLASS_PROVIDER.XAI.LARGE,
+            SMALL: FIRST_CLASS_PROVIDER.XAI.SMALL,
+            TINY: FIRST_CLASS_PROVIDER.XAI.TINY,
+        },
+        MODEL_MATCH_WORDS: ["grok", "xai"],
+        NAME: "xai",
+    },
 };
 // Last: Defaults
 const DEFAULT = {
@@ -133,37 +190,47 @@ const DEFAULT = {
 const ALL = {
     BASE: [
         PROVIDER.ANTHROPIC.MODEL.DEFAULT,
-        PROVIDER.GEMINI.MODEL.DEFAULT,
+        PROVIDER.GOOGLE.MODEL.DEFAULT,
         PROVIDER.OPENAI.MODEL.DEFAULT,
+        PROVIDER.XAI.MODEL.DEFAULT,
     ],
     COMBINED: [
-        PROVIDER.ANTHROPIC.MODEL.DEFAULT,
-        PROVIDER.ANTHROPIC.MODEL.LARGE,
-        PROVIDER.ANTHROPIC.MODEL.SMALL,
-        PROVIDER.ANTHROPIC.MODEL.TINY,
-        PROVIDER.GEMINI.MODEL.DEFAULT,
-        PROVIDER.GEMINI.MODEL.LARGE,
-        PROVIDER.GEMINI.MODEL.SMALL,
-        PROVIDER.GEMINI.MODEL.TINY,
-        PROVIDER.OPENAI.MODEL.DEFAULT,
-        PROVIDER.OPENAI.MODEL.LARGE,
-        PROVIDER.OPENAI.MODEL.SMALL,
-        PROVIDER.OPENAI.MODEL.TINY,
+        ...new Set([
+            PROVIDER.ANTHROPIC.MODEL.DEFAULT,
+            PROVIDER.ANTHROPIC.MODEL.LARGE,
+            PROVIDER.ANTHROPIC.MODEL.SMALL,
+            PROVIDER.ANTHROPIC.MODEL.TINY,
+            PROVIDER.GOOGLE.MODEL.DEFAULT,
+            PROVIDER.GOOGLE.MODEL.LARGE,
+            PROVIDER.GOOGLE.MODEL.SMALL,
+            PROVIDER.GOOGLE.MODEL.TINY,
+            PROVIDER.OPENAI.MODEL.DEFAULT,
+            PROVIDER.OPENAI.MODEL.LARGE,
+            PROVIDER.OPENAI.MODEL.SMALL,
+            PROVIDER.OPENAI.MODEL.TINY,
+            PROVIDER.XAI.MODEL.DEFAULT,
+            PROVIDER.XAI.MODEL.LARGE,
+            PROVIDER.XAI.MODEL.SMALL,
+            PROVIDER.XAI.MODEL.TINY,
+        ]),
     ],
     LARGE: [
         PROVIDER.ANTHROPIC.MODEL.LARGE,
-        PROVIDER.GEMINI.MODEL.LARGE,
+        PROVIDER.GOOGLE.MODEL.LARGE,
         PROVIDER.OPENAI.MODEL.LARGE,
+        PROVIDER.XAI.MODEL.LARGE,
     ],
     SMALL: [
         PROVIDER.ANTHROPIC.MODEL.SMALL,
-        PROVIDER.GEMINI.MODEL.SMALL,
+        PROVIDER.GOOGLE.MODEL.SMALL,
         PROVIDER.OPENAI.MODEL.SMALL,
+        PROVIDER.XAI.MODEL.SMALL,
     ],
     TINY: [
         PROVIDER.ANTHROPIC.MODEL.TINY,
-        PROVIDER.GEMINI.MODEL.TINY,
+        PROVIDER.GOOGLE.MODEL.TINY,
         PROVIDER.OPENAI.MODEL.TINY,
+        PROVIDER.XAI.MODEL.TINY,
     ],
 };
 
@@ -171,6 +238,7 @@ var constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ALL: ALL,
     DEFAULT: DEFAULT,
+    MODEL: MODEL,
     PROVIDER: PROVIDER
 });
 
@@ -189,17 +257,31 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
+    // Check for explicit bedrock: prefix
+    if (input.startsWith("bedrock:")) {
+        const model = input.slice("bedrock:".length);
+        return {
+            model,
+            provider: PROVIDER.BEDROCK.NAME,
+        };
+    }
     // Check if input is a provider name
+    if (input === PROVIDER.BEDROCK.NAME) {
+        return {
+            model: PROVIDER.BEDROCK.MODEL.DEFAULT,
+            provider: PROVIDER.BEDROCK.NAME,
+        };
+    }
     if (input === PROVIDER.ANTHROPIC.NAME) {
         return {
             model: PROVIDER.ANTHROPIC.MODEL.DEFAULT,
             provider: PROVIDER.ANTHROPIC.NAME,
         };
     }
-    if (input === PROVIDER.GEMINI.NAME) {
+    if (input === PROVIDER.GOOGLE.NAME || input === "gemini") {
         return {
-            model: PROVIDER.GEMINI.MODEL.DEFAULT,
-            provider: PROVIDER.GEMINI.NAME,
+            model: PROVIDER.GOOGLE.MODEL.DEFAULT,
+            provider: PROVIDER.GOOGLE.NAME,
         };
     }
     if (input === PROVIDER.OPENAI.NAME) {
@@ -214,6 +296,12 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
+    if (input === PROVIDER.XAI.NAME) {
+        return {
+            model: PROVIDER.XAI.MODEL.DEFAULT,
+            provider: PROVIDER.XAI.NAME,
+        };
+    }
     // Check if input matches an Anthropic model exactly
     for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
         if (input === modelValue) {
@@ -224,11 +312,11 @@ function determineModelProvider(input) {
         }
     }
     // Check if input matches a Gemini model exactly
-    for (const [, modelValue] of Object.entries(PROVIDER.GEMINI.MODEL)) {
+    for (const [, modelValue] of Object.entries(PROVIDER.GOOGLE.MODEL)) {
         if (input === modelValue) {
             return {
                 model: input,
-                provider: PROVIDER.GEMINI.NAME,
+                provider: PROVIDER.GOOGLE.NAME,
             };
         }
     }
@@ -250,6 +338,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check if input matches an xAI model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.XAI.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.XAI.NAME,
+            };
+        }
+    }
     // Assume OpenRouter for models containing "/" (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
     // This check must come before match words so that "openai/gpt-4" is not matched by "openai" keyword
     if (input.includes("/")) {
@@ -258,8 +355,17 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
-    // Check Anthropic match words
+    // Check Bedrock match words (before Anthropic — "anthropic.claude-*" is a Bedrock model ID)
     const lowerInput = input.toLowerCase();
+    for (const matchWord of PROVIDER.BEDROCK.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.BEDROCK.NAME,
+            };
+        }
+    }
+    // Check Anthropic match words
     for (const matchWord of PROVIDER.ANTHROPIC.MODEL_MATCH_WORDS) {
         if (lowerInput.includes(matchWord)) {
             return {
@@ -269,11 +375,11 @@ function determineModelProvider(input) {
         }
     }
     // Check Gemini match words
-    for (const matchWord of PROVIDER.GEMINI.MODEL_MATCH_WORDS) {
+    for (const matchWord of PROVIDER.GOOGLE.MODEL_MATCH_WORDS) {
         if (lowerInput.includes(matchWord)) {
             return {
                 model: input,
-                provider: PROVIDER.GEMINI.NAME,
+                provider: PROVIDER.GOOGLE.NAME,
             };
         }
     }
@@ -296,6 +402,15 @@ function determineModelProvider(input) {
             }
         }
     }
+    // Check xAI match words
+    for (const matchWord of PROVIDER.XAI.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.XAI.NAME,
+            };
+        }
+    }
     // Check OpenRouter match words
     for (const matchWord of PROVIDER.OPENROUTER.MODEL_MATCH_WORDS) {
         if (lowerInput.includes(matchWord)) {
@@ -460,6 +575,154 @@ function extractReasoning(history) {
     return reasoningTexts;
 }
 
+function naturalZodSchema(definition) {
+    if (Array.isArray(definition)) {
+        if (definition.length === 0) {
+            // Handle empty array - accept any[]
+            return v4.z.array(v4.z.any());
+        }
+        else if (definition.length === 1) {
+            // Handle array types
+            const itemType = definition[0];
+            switch (itemType) {
+                case String:
+                    return v4.z.array(v4.z.string());
+                case Number:
+                    return v4.z.array(v4.z.number());
+                case Boolean:
+                    return v4.z.array(v4.z.boolean());
+                default:
+                    if (typeof itemType === "object") {
+                        // Handle array of objects
+                        return v4.z.array(naturalZodSchema(itemType));
+                    }
+                    // Handle enum arrays
+                    return v4.z.enum(definition);
+            }
+        }
+        else {
+            // Handle enum arrays
+            return v4.z.enum(definition);
+        }
+    }
+    else if (definition && typeof definition === "object") {
+        if (Object.keys(definition).length === 0) {
+            // Handle empty object - accept any key-value pairs
+            return v4.z.record(v4.z.string(), v4.z.any());
+        }
+        else {
+            // Handle object with properties
+            const schemaShape = {};
+            for (const [key, value] of Object.entries(definition)) {
+                schemaShape[key] = naturalZodSchema(value);
+            }
+            return v4.z.object(schemaShape);
+        }
+    }
+    else {
+        switch (definition) {
+            case String:
+                return v4.z.string();
+            case Number:
+                return v4.z.number();
+            case Boolean:
+                return v4.z.boolean();
+            case Object:
+                return v4.z.record(v4.z.string(), v4.z.any());
+            case Array:
+                return v4.z.array(v4.z.any());
+            default:
+                throw new Error(`Unsupported type: ${definition}`);
+        }
+    }
+}
+
+//
+//
+// Helpers
+//
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Convert a `format` declaration (Zod schema, NaturalSchema, or a JSON Schema
+ * JsonObject) into a plain JSON Schema we can walk. Mirrors the conversion the
+ * provider adapters perform in `formatOutputSchema`, but without any
+ * provider-specific sanitization.
+ */
+function formatToJsonSchema(format) {
+    if (format instanceof v4.z.ZodType) {
+        return v4.z.toJSONSchema(format);
+    }
+    if (isPlainObject(format) && format.type === "json_schema") {
+        const clone = structuredClone(format);
+        clone.type = "object";
+        return clone;
+    }
+    try {
+        return v4.z.toJSONSchema(naturalZodSchema(format));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Walk a JSON Schema alongside a parsed value, filling any declared array field
+ * that is absent (`undefined`/`null`) with `[]`. Recurses into object
+ * properties and array items so nested declared arrays are also backfilled.
+ */
+function fillFromSchema(schema, value) {
+    if (!isPlainObject(schema)) {
+        return value;
+    }
+    const type = schema.type;
+    const isArray = type === "array" || (type === undefined && "items" in schema);
+    if (isArray) {
+        if (value === undefined || value === null) {
+            return [];
+        }
+        const items = schema.items;
+        if (Array.isArray(value) && isPlainObject(items)) {
+            return value.map((entry) => fillFromSchema(items, entry));
+        }
+        return value;
+    }
+    const isObject = type === "object" || (type === undefined && "properties" in schema);
+    if (isObject) {
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const properties = schema.properties;
+        if (isPlainObject(properties)) {
+            for (const [key, propSchema] of Object.entries(properties)) {
+                value[key] = fillFromSchema(propSchema, value[key]);
+            }
+        }
+        return value;
+    }
+    return value;
+}
+//
+//
+// Main
+//
+/**
+ * Ensure every array field declared in `format` is present in `content` as an
+ * array. A declared `format` is a schema contract: an empty list should surface
+ * as `[]`, not be dropped from the response. Some providers/models omit empty
+ * array fields entirely, leaving consumers to read `.length` on `undefined`.
+ *
+ * Only mutates a (cloned) structured object; strings and non-objects pass
+ * through untouched.
+ */
+function fillFormatArrays({ content, format, }) {
+    const schema = formatToJsonSchema(format);
+    if (!schema) {
+        return content;
+    }
+    return fillFromSchema(schema, structuredClone(content));
+}
+
 /**
  * Converts a string to a standardized LlmInputMessage
  * @param input - String to format
@@ -507,12 +770,53 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$4 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
-const log$1 = getLogger$4();
+/**
+ * Converts a JSON Schema (Draft 2020-12) object to the OpenAPI 3.0 schema subset
+ * that Gemini's `responseSchema` accepts. This constrains generation (not just validation)
+ * and avoids the `items`-keyword leakage bug in `responseJsonSchema`.
+ *
+ * Strips: $schema, additionalProperties, $defs, $ref (inlines where possible), const
+ * Preserves: type, properties, required, items, enum, description, nullable
+ */
+function jsonSchemaToOpenApi3(schema) {
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return schema;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Strip JSON Schema keywords not in OpenAPI 3.0 subset
+        if (key === "$schema" ||
+            key === "$defs" ||
+            key === "additionalProperties" ||
+            key === "const" ||
+            key === "$ref") {
+            continue;
+        }
+        if (key === "properties" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            const convertedProps = {};
+            for (const [propKey, propValue] of Object.entries(value)) {
+                convertedProps[propKey] = jsonSchemaToOpenApi3(propValue);
+            }
+            result[key] = convertedProps;
+        }
+        else if (key === "items" && typeof value === "object" && value !== null) {
+            result[key] = jsonSchemaToOpenApi3(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
-const MAX_TURNS_DEFAULT_LIMIT = 12;
+const MAX_TURNS_DEFAULT_LIMIT = 24;
 /**
  * Determines the maximum number of turns based on the provided options
  *
@@ -546,68 +850,6 @@ function maxTurnsFromOptions(options) {
     return 1;
 }
 
-function naturalZodSchema(definition) {
-    if (Array.isArray(definition)) {
-        if (definition.length === 0) {
-            // Handle empty array - accept any[]
-            return v4.z.array(v4.z.any());
-        }
-        else if (definition.length === 1) {
-            // Handle array types
-            const itemType = definition[0];
-            switch (itemType) {
-                case String:
-                    return v4.z.array(v4.z.string());
-                case Number:
-                    return v4.z.array(v4.z.number());
-                case Boolean:
-                    return v4.z.array(v4.z.boolean());
-                default:
-                    if (typeof itemType === "object") {
-                        // Handle array of objects
-                        return v4.z.array(naturalZodSchema(itemType));
-                    }
-                    // Handle enum arrays
-                    return v4.z.enum(definition);
-            }
-        }
-        else {
-            // Handle enum arrays
-            return v4.z.enum(definition);
-        }
-    }
-    else if (definition && typeof definition === "object") {
-        if (Object.keys(definition).length === 0) {
-            // Handle empty object - accept any key-value pairs
-            return v4.z.record(v4.z.string(), v4.z.any());
-        }
-        else {
-            // Handle object with properties
-            const schemaShape = {};
-            for (const [key, value] of Object.entries(definition)) {
-                schemaShape[key] = naturalZodSchema(value);
-            }
-            return v4.z.object(schemaShape);
-        }
-    }
-    else {
-        switch (definition) {
-            case String:
-                return v4.z.string();
-            case Number:
-                return v4.z.number();
-            case Boolean:
-                return v4.z.boolean();
-            case Object:
-                return v4.z.record(v4.z.string(), v4.z.any());
-            case Array:
-                return v4.z.array(v4.z.any());
-            default:
-                throw new Error(`Unsupported type: ${definition}`);
-        }
-    }
-}
-
 //
 // Constants
 //
@@ -807,26 +1049,242 @@ var ErrorCategory;
     ErrorCategory["Unknown"] = "unknown";
 })(ErrorCategory || (ErrorCategory = {}));
 
+/**
+ * Transient network error detection utility.
+ *
+ * Detects low-level Node.js/undici network errors that indicate
+ * a temporary network issue (not a provider API error).
+ * These errors should always be retried.
+ */
 //
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
-// Regular expression to parse data URLs: data:mime/type;base64,data
-const DATA_URL_REGEX = /^data:([^;]+);base64,(.+)$/;
-/**
- * Parse a data URL into its components
- */
-function parseDataUrl(dataUrl) {
-    const match = dataUrl.match(DATA_URL_REGEX);
-    if (!match)
-        return null;
-    return { mediaType: match[1], data: match[2] };
-}
+/** Error codes from Node.js net/dns subsystems that indicate transient failures */
+const TRANSIENT_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "EAI_AGAIN",
+    "ENETRESET",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "EPIPE",
+    "ETIMEDOUT",
+]);
+/** Substrings in error messages that indicate transient network issues */
+const TRANSIENT_MESSAGE_PATTERNS = [
+    "network",
+    "socket hang up",
+    "terminated",
+];
+//
+//
+// Helpers
+//
 /**
- * Convert standardized content items to Anthropic format
+ * Check a single error (without walking the cause chain)
  */
-function convertContentToAnthropic(content) {
+function matchesSingleError(error) {
+    if (!(error instanceof Error))
+        return false;
+    // Check error code (e.g., ECONNRESET)
+    const code = error.code;
+    if (code && TRANSIENT_ERROR_CODES.has(code)) {
+        return true;
+    }
+    // Check error message for transient patterns
+    const message = error.message.toLowerCase();
+    for (const pattern of TRANSIENT_MESSAGE_PATTERNS) {
+        if (message.includes(pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+//
+//
+// Main
+//
+/**
+ * Detect transient network errors by inspecting the error and its cause chain.
+ *
+ * Undici (Node.js fetch) wraps low-level errors like ECONNRESET inside
+ * `TypeError: terminated`. This function recursively walks `error.cause`
+ * to detect these wrapped errors.
+ *
+ * @param error - The error to inspect
+ * @returns true if the error (or any cause in its chain) is a transient network error
+ */
+function isTransientNetworkError(error) {
+    let current = error;
+    while (current) {
+        if (matchesSingleError(current)) {
+            return true;
+        }
+        // Walk the cause chain (cause is ES2022, cast for compatibility)
+        const cause = current.cause;
+        if (current instanceof Error && cause) {
+            current = cause;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME$3 = "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$1 = /^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
+ */
+function parseDataUrl(dataUrl) {
+    const match = dataUrl.match(DATA_URL_REGEX$1);
+    if (!match)
+        return null;
+    return { mediaType: match[1], data: match[2] };
+}
+/**
+ * Convert standardized content items to Anthropic format
+ */
+function convertContentToAnthropic(content) {
     if (typeof content === "string") {
         return content;
     }
@@ -891,6 +1349,47 @@ const NOT_RETRYABLE_ERROR_NAMES = [
     "NotFoundError",
     "PermissionDeniedError",
 ];
+// Models known not to accept `temperature`.
+// Patterns (not exact names) so dated variants and future releases are covered
+// without code changes — Anthropic is trending toward removing temperature on
+// newer Claude models.
+const MODELS_WITHOUT_TEMPERATURE$2 = [
+    /^claude-opus-4-[789]/,
+    /^claude-opus-[5-9]/,
+];
+function isTemperatureDeprecationError$3(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");
+    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
@@ -905,6 +1404,33 @@ class AnthropicAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.ANTHROPIC.NAME;
         this.defaultModel = PROVIDER.ANTHROPIC.MODEL.DEFAULT;
+        // 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);
+    }
+    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$2.some((pattern) => pattern.test(model));
+    }
+    supportsStructuredOutput(model) {
+        return !this.runtimeNoStructuredOutputModels.has(model);
     }
     //
     // Request Building
@@ -973,8 +1499,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$3,
+                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: {
@@ -983,10 +1523,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) {
@@ -996,10 +1545,20 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (request.temperature !== undefined) {
             anthropicRequest.temperature = request.temperature;
         }
+        // Strip temperature for models that don't support it (denylist + runtime cache)
+        if (anthropicRequest.temperature !== undefined &&
+            !this.supportsTemperature(anthropicRequest.model)) {
+            delete anthropicRequest.temperature;
+        }
         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: {
@@ -1007,16 +1566,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;
@@ -1035,26 +1584,100 @@ 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
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const anthropic = client;
-        return (await anthropic.messages.create(request));
+        const anthropicRequest = request;
+        const wantsStructuredOutput = Boolean(anthropicRequest.output_config);
+        try {
+            const response = (await anthropic.messages.create(anthropicRequest, signal ? { signal } : undefined));
+            if (wantsStructuredOutput) {
+                response.__jaypieStructuredOutput = true;
+            }
+            return response;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            // If the model rejected `temperature`, cache it and retry without the param
+            if (anthropicRequest.temperature !== undefined &&
+                isTemperatureDeprecationError$3(error)) {
+                this.rememberModelRejectsTemperature(anthropicRequest.model);
+                const retryRequest = { ...anthropicRequest };
+                delete retryRequest.temperature;
+                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$3,
+            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) {
+    async *executeStreamRequest(client, request, signal) {
         const anthropic = client;
-        const streamRequest = {
+        // 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,
         };
-        const stream = await anthropic.messages.create(streamRequest);
+        let stream;
+        try {
+            stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
+        }
+        catch (error) {
+            if (streamRequest.temperature !== undefined &&
+                isTemperatureDeprecationError$3(error)) {
+                this.rememberModelRejectsTemperature(streamRequest.model);
+                streamRequest = {
+                    ...streamRequest,
+                };
+                delete streamRequest.temperature;
+                stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
+            }
+            else {
+                throw error;
+            }
+        }
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -1141,43 +1764,659 @@ class AnthropicAdapter extends BaseProviderAdapter {
     //
     // Response Parsing
     //
-    parseResponse(response, _options) {
-        const anthropicResponse = response;
-        const content = this.extractContent(anthropicResponse);
-        const hasToolCalls = anthropicResponse.stop_reason === "tool_use";
+    parseResponse(response, _options) {
+        const anthropicResponse = response;
+        const content = this.extractContent(anthropicResponse);
+        const hasToolCalls = anthropicResponse.stop_reason === "tool_use";
+        return {
+            content,
+            hasToolCalls,
+            stopReason: anthropicResponse.stop_reason ?? undefined,
+            usage: this.extractUsage(anthropicResponse, anthropicResponse.model),
+            raw: anthropicResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const anthropicResponse = response;
+        const toolCalls = [];
+        for (const block of anthropicResponse.content) {
+            if (block.type === "tool_use") {
+                toolCalls.push({
+                    callId: block.id,
+                    name: block.name,
+                    arguments: JSON.stringify(block.input),
+                    raw: block,
+                });
+            }
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const anthropicResponse = response;
+        // Check for thinking tokens in the usage (extended thinking feature)
+        // Anthropic includes thinking tokens in a separate field when enabled
+        const usage = anthropicResponse.usage;
+        return {
+            input: usage.input_tokens,
+            output: usage.output_tokens,
+            reasoning: usage.thinking_tokens || 0,
+            total: usage.input_tokens + usage.output_tokens,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            type: "tool_result",
+            tool_use_id: toolCall.callId,
+            content: result.output,
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const anthropicRequest = request;
+        const toolCallRaw = toolCall.raw;
+        // Add assistant message with the tool use
+        anthropicRequest.messages.push({
+            role: "assistant",
+            content: [toolCallRaw],
+        });
+        // Add user message with the tool result
+        anthropicRequest.messages.push({
+            role: "user",
+            content: [this.formatToolResult(toolCall, result)],
+        });
+        return anthropicRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const anthropicResponse = response;
+        const historyItems = [];
+        // Check if this is a tool use response
+        if (anthropicResponse.stop_reason === "tool_use") {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Include thinking blocks for extended thinking support
+        // Thinking blocks are preserved in history so extractReasoning can find them
+        for (const block of anthropicResponse.content) {
+            if (block.type === "thinking") {
+                // Push raw block - types are loosely checked at runtime
+                // This allows extractReasoning to access the thinking property
+                historyItems.push(block);
+            }
+        }
+        // Extract text content for non-tool responses
+        const textBlock = anthropicResponse.content.find((block) => block.type === "text");
+        if (textBlock) {
+            historyItems.push({
+                content: textBlock.text,
+                role: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+                type: exports.LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        const errorName = error?.constructor?.name;
+        // Check for rate limit error
+        if (errorName === "RateLimitError") {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Check for retryable errors
+        if (RETRYABLE_ERROR_NAMES.includes(errorName)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        // Check for non-retryable errors
+        if (NOT_RETRYABLE_ERROR_NAMES.includes(errorName)) {
+            return {
+                error,
+                category: ErrorCategory.Unrecoverable,
+                shouldRetry: false,
+            };
+        }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const anthropicResponse = response;
+        return anthropicResponse.stop_reason !== "tool_use";
+    }
+    hasStructuredOutput(response) {
+        const anthropicResponse = response;
+        // 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$3);
+    }
+    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$3) {
+            return lastBlock.input;
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    extractContent(response) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        // Extract text content
+        const textBlock = response.content.find((block) => block.type === "text");
+        return textBlock?.text;
+    }
+}
+// Export singleton instance
+const anthropicAdapter = new AnthropicAdapter();
+
+//
+//
+// Helpers
+//
+// Regular expression to parse data URLs
+const DATA_URL_REGEX = /^data:([^;]+);base64,(.+)$/;
+const MIME_TO_DOCUMENT_FORMAT = {
+    "application/pdf": "pdf",
+    "text/csv": "csv",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/markdown": "md",
+};
+function convertContentToBedrock(content) {
+    if (typeof content === "string") {
+        return [{ text: content }];
+    }
+    return content.map((item) => {
+        if (item.type === exports.LlmMessageType.InputText) {
+            return { text: item.text };
+        }
+        if (item.type === exports.LlmMessageType.InputImage) {
+            const imageUrl = item.image_url || "";
+            const match = imageUrl.match(DATA_URL_REGEX);
+            if (match) {
+                const format = match[1].split("/")[1] || "jpeg";
+                const bytes = Buffer.from(match[2], "base64");
+                return {
+                    image: {
+                        format,
+                        source: { bytes: new Uint8Array(bytes) },
+                    },
+                };
+            }
+            return { text: `[Image: ${imageUrl}]` };
+        }
+        if (item.type === exports.LlmMessageType.InputFile) {
+            const fileData = typeof item.file_data === "string" ? item.file_data : "";
+            const match = fileData.match(DATA_URL_REGEX);
+            if (match) {
+                const mimeType = match[1];
+                const documentFormat = MIME_TO_DOCUMENT_FORMAT[mimeType];
+                if (documentFormat) {
+                    const bytes = Buffer.from(match[2], "base64");
+                    const rawName = item.filename || "document";
+                    const name = rawName.replace(/[^a-zA-Z0-9 \-()[\]]/g, "_");
+                    return {
+                        document: {
+                            format: documentFormat,
+                            name,
+                            source: { bytes: new Uint8Array(bytes) },
+                        },
+                    };
+                }
+            }
+            return { text: `[File: ${item.filename || "unknown"}]` };
+        }
+        return { text: JSON.stringify(item) };
+    });
+}
+//
+//
+// Constants / helpers
+//
+const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+function isOutputConfigUnsupportedError(error) {
+    const msg = error?.message ?? "";
+    return /outputConfig|output_config/i.test(msg);
+}
+function isTemperatureDeprecationError$2(error) {
+    const msg = error?.message ?? "";
+    return /temperature.*deprecated|deprecated.*temperature/i.test(msg);
+}
+function extractJson(text) {
+    // Try direct parse first
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "object" && parsed !== null)
+            return parsed;
+    }
+    catch {
+        // fall through
+    }
+    // Try stripping markdown code fences
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            const parsed = JSON.parse(fenceMatch[1].trim());
+            if (typeof parsed === "object" && parsed !== null)
+                return parsed;
+        }
+        catch {
+            // fall through
+        }
+    }
+    return undefined;
+}
+//
+//
+// Main
+//
+class BedrockAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.BEDROCK.NAME;
+        this.defaultModel = PROVIDER.BEDROCK.MODEL.DEFAULT;
+        this._modelsFallbackToStructuredOutputTool = new Set();
+        this._modelsWithoutTemperature = new Set();
+    }
+    rememberModelRejectsOutputConfig(model) {
+        this._modelsFallbackToStructuredOutputTool.add(model);
+    }
+    useFakeToolForStructuredOutput(model) {
+        return this._modelsFallbackToStructuredOutputTool.has(model);
+    }
+    rememberModelRejectsTemperature(model) {
+        this._modelsWithoutTemperature.add(model);
+    }
+    supportsTemperature(model) {
+        return !this._modelsWithoutTemperature.has(model);
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        const messages = [];
+        for (const msg of request.messages) {
+            const typedMsg = msg;
+            if (typedMsg.role === "system")
+                continue;
+            if (typedMsg.type === exports.LlmMessageType.FunctionCall) {
+                let parsedInput;
+                try {
+                    parsedInput = JSON.parse(typedMsg.arguments || "{}");
+                }
+                catch {
+                    parsedInput = {};
+                }
+                messages.push({
+                    role: "assistant",
+                    content: [
+                        {
+                            toolUse: {
+                                toolUseId: typedMsg.call_id || "",
+                                name: typedMsg.name || "",
+                                input: parsedInput,
+                            },
+                        },
+                    ],
+                });
+                continue;
+            }
+            if (typedMsg.type === exports.LlmMessageType.FunctionCallOutput) {
+                messages.push({
+                    role: "user",
+                    content: [
+                        {
+                            toolResult: {
+                                toolUseId: typedMsg.call_id || "",
+                                content: [{ text: typedMsg.output || "" }],
+                            },
+                        },
+                    ],
+                });
+                continue;
+            }
+            if (typedMsg.role && typedMsg.content !== undefined) {
+                messages.push({
+                    role: typedMsg.role,
+                    content: convertContentToBedrock(typedMsg.content),
+                });
+            }
+        }
+        const model = request.model || this.defaultModel;
+        const bedrockRequest = {
+            modelId: model,
+            messages,
+            inferenceConfig: {
+                maxTokens: 4096,
+            },
+        };
+        if (request.system) {
+            bedrockRequest.system = [{ text: request.system }];
+        }
+        if (request.temperature !== undefined && this.supportsTemperature(model)) {
+            bedrockRequest.inferenceConfig = {
+                ...bedrockRequest.inferenceConfig,
+                temperature: request.temperature,
+            };
+        }
+        if (request.tools && request.tools.length > 0) {
+            bedrockRequest.toolConfig = {
+                tools: request.tools.map((tool) => ({
+                    toolSpec: {
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: {
+                            json: tool.parameters,
+                        },
+                    },
+                })),
+            };
+        }
+        if (request.instructions && messages.length > 0) {
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg.content.length > 0) {
+                const firstBlock = lastMsg.content[0];
+                if ("text" in firstBlock) {
+                    firstBlock.text = firstBlock.text + "\n\n" + request.instructions;
+                }
+            }
+        }
+        if (request.format) {
+            if (this.useFakeToolForStructuredOutput(model)) {
+                const fakeTool = {
+                    toolSpec: {
+                        name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                        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.",
+                        inputSchema: { json: request.format },
+                    },
+                };
+                bedrockRequest.toolConfig = {
+                    tools: [
+                        ...(bedrockRequest.toolConfig?.tools ?? []),
+                        fakeTool,
+                    ],
+                };
+            }
+            else {
+                bedrockRequest.outputConfig = {
+                    textFormat: {
+                        type: "json_schema",
+                        structure: {
+                            jsonSchema: {
+                                schema: JSON.stringify(request.format),
+                                name: "structured_output",
+                            },
+                        },
+                    },
+                };
+            }
+        }
+        if (request.providerOptions) {
+            Object.assign(bedrockRequest, request.providerOptions);
+        }
+        return bedrockRequest;
+    }
+    formatTools(toolkit) {
+        return toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                ...tool.parameters,
+                type: "object",
+            },
+        }));
+    }
+    formatOutputSchema(schema) {
+        const zodSchema = schema instanceof v4.z.ZodType
+            ? schema
+            : naturalZodSchema(schema);
+        return v4.z.toJSONSchema(zodSchema);
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request, signal) {
+        const bedrockClient = client;
+        const bedrockRequest = request;
+        const { ConverseCommand } = await import('@aws-sdk/client-bedrock-runtime');
+        const wantsStructuredOutput = Boolean(bedrockRequest.outputConfig);
+        try {
+            const response = (await bedrockClient.send(new ConverseCommand(bedrockRequest), signal ? { abortSignal: signal } : undefined));
+            if (wantsStructuredOutput)
+                response.__jaypieStructuredOutput = true;
+            return response;
+        }
+        catch (error) {
+            if (bedrockRequest.inferenceConfig?.temperature !== undefined &&
+                isTemperatureDeprecationError$2(error)) {
+                this.rememberModelRejectsTemperature(bedrockRequest.modelId || this.defaultModel);
+                const retryRequest = {
+                    ...bedrockRequest,
+                    inferenceConfig: { ...bedrockRequest.inferenceConfig },
+                };
+                delete retryRequest.inferenceConfig.temperature;
+                const response = (await bedrockClient.send(new ConverseCommand(retryRequest), signal ? { abortSignal: signal } : undefined));
+                if (wantsStructuredOutput)
+                    response.__jaypieStructuredOutput = true;
+                return response;
+            }
+            if (wantsStructuredOutput && isOutputConfigUnsupportedError(error)) {
+                const model = bedrockRequest.modelId || this.defaultModel;
+                this.rememberModelRejectsOutputConfig(model);
+                const fallbackRequest = this.toFallbackStructuredOutputRequest(bedrockRequest);
+                return (await bedrockClient.send(new ConverseCommand(fallbackRequest), signal ? { abortSignal: signal } : undefined));
+            }
+            throw error;
+        }
+    }
+    toFallbackStructuredOutputRequest(request) {
+        const { outputConfig, ...rest } = request;
+        if (!outputConfig?.textFormat?.structure)
+            return request;
+        let schema;
+        try {
+            schema = JSON.parse(outputConfig.textFormat.structure.jsonSchema?.schema ?? "{}");
+        }
+        catch {
+            schema = {};
+        }
+        const fakeTool = {
+            toolSpec: {
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                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.",
+                inputSchema: { json: schema },
+            },
+        };
+        return {
+            ...rest,
+            toolConfig: {
+                tools: [...(rest.toolConfig?.tools ?? []), fakeTool],
+            },
+        };
+    }
+    async *executeStreamRequest(client, request, signal) {
+        const bedrockClient = client;
+        const bedrockRequest = request;
+        const { ConverseStreamCommand } = await import('@aws-sdk/client-bedrock-runtime');
+        const response = await bedrockClient.send(new ConverseStreamCommand(bedrockRequest), signal ? { abortSignal: signal } : undefined);
+        if (!response.stream)
+            return;
+        let currentToolCall = null;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        const model = bedrockRequest.modelId || this.defaultModel;
+        for await (const event of response.stream) {
+            if (event.contentBlockStart?.start?.toolUse) {
+                const toolUse = event.contentBlockStart.start.toolUse;
+                currentToolCall = {
+                    toolUseId: toolUse.toolUseId || "",
+                    name: toolUse.name || "",
+                    arguments: "",
+                };
+            }
+            else if (event.contentBlockDelta?.delta) {
+                const delta = event.contentBlockDelta.delta;
+                if (delta.text !== undefined) {
+                    yield { type: exports.LlmStreamChunkType.Text, content: delta.text };
+                }
+                else if (delta.toolUse?.input && currentToolCall) {
+                    currentToolCall.arguments += delta.toolUse.input;
+                }
+            }
+            else if (event.contentBlockStop && currentToolCall) {
+                yield {
+                    type: exports.LlmStreamChunkType.ToolCall,
+                    toolCall: {
+                        id: currentToolCall.toolUseId,
+                        name: currentToolCall.name,
+                        arguments: currentToolCall.arguments,
+                    },
+                };
+                currentToolCall = null;
+            }
+            else if (event.metadata?.usage) {
+                inputTokens = event.metadata.usage.inputTokens ?? 0;
+                outputTokens = event.metadata.usage.outputTokens ?? 0;
+            }
+            else if (event.messageStop) {
+                yield {
+                    type: exports.LlmStreamChunkType.Done,
+                    usage: [
+                        {
+                            input: inputTokens,
+                            output: outputTokens,
+                            reasoning: 0,
+                            total: inputTokens + outputTokens,
+                            provider: this.name,
+                            model,
+                        },
+                    ],
+                };
+            }
+        }
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, options) {
+        const bedrockResponse = response;
+        const message = bedrockResponse.output?.message;
+        const rawContent = this.extractContentFromMessage(message);
+        let content = rawContent;
+        if (options?.format && typeof rawContent === "string") {
+            content = extractJson(rawContent) ?? rawContent;
+        }
+        // Don't surface structured_output fake tool as a real tool call
+        const allToolUses = (bedrockResponse.output?.message?.content ?? []).filter((b) => "toolUse" in b);
+        const hasOnlyStructuredOutputTool = allToolUses.length > 0 &&
+            allToolUses.every((b) => b.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+        const hasToolCalls = bedrockResponse.stopReason === "tool_use" && !hasOnlyStructuredOutputTool;
         return {
             content,
             hasToolCalls,
-            stopReason: anthropicResponse.stop_reason ?? undefined,
-            usage: this.extractUsage(anthropicResponse, anthropicResponse.model),
-            raw: anthropicResponse,
+            stopReason: bedrockResponse.stopReason ?? undefined,
+            usage: this.extractUsage(bedrockResponse, bedrockResponse.modelId ||
+                this.defaultModel),
+            raw: bedrockResponse,
         };
     }
     extractToolCalls(response) {
-        const anthropicResponse = response;
+        const bedrockResponse = response;
+        const content = bedrockResponse.output?.message?.content ?? [];
         const toolCalls = [];
-        for (const block of anthropicResponse.content) {
-            if (block.type === "tool_use") {
+        for (const block of content) {
+            const typedBlock = block;
+            if ("toolUse" in typedBlock && typedBlock.toolUse) {
+                const toolUse = typedBlock.toolUse;
                 toolCalls.push({
-                    callId: block.id,
-                    name: block.name,
-                    arguments: JSON.stringify(block.input),
-                    raw: block,
+                    callId: toolUse.toolUseId,
+                    name: toolUse.name,
+                    arguments: JSON.stringify(toolUse.input),
+                    raw: typedBlock,
                 });
             }
         }
         return toolCalls;
     }
     extractUsage(response, model) {
-        const anthropicResponse = response;
-        // Check for thinking tokens in the usage (extended thinking feature)
-        // Anthropic includes thinking tokens in a separate field when enabled
-        const usage = anthropicResponse.usage;
+        const bedrockResponse = response;
+        const usage = bedrockResponse.usage;
         return {
-            input: usage.input_tokens,
-            output: usage.output_tokens,
-            reasoning: usage.thinking_tokens || 0,
-            total: usage.input_tokens + usage.output_tokens,
+            input: usage?.inputTokens ?? 0,
+            output: usage?.outputTokens ?? 0,
+            reasoning: 0,
+            total: usage?.totalTokens ??
+                (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0),
             provider: this.name,
             model,
         };
@@ -1187,52 +2426,40 @@ class AnthropicAdapter extends BaseProviderAdapter {
     //
     formatToolResult(toolCall, result) {
         return {
-            type: "tool_result",
-            tool_use_id: toolCall.callId,
-            content: result.output,
+            toolResult: {
+                toolUseId: toolCall.callId,
+                content: [{ text: result.output }],
+            },
         };
     }
     appendToolResult(request, toolCall, result) {
-        const anthropicRequest = request;
+        const bedrockRequest = request;
         const toolCallRaw = toolCall.raw;
-        // Add assistant message with the tool use
-        anthropicRequest.messages.push({
+        bedrockRequest.messages.push({
             role: "assistant",
             content: [toolCallRaw],
         });
-        // Add user message with the tool result
-        anthropicRequest.messages.push({
+        bedrockRequest.messages.push({
             role: "user",
             content: [this.formatToolResult(toolCall, result)],
         });
-        return anthropicRequest;
+        return bedrockRequest;
     }
     //
     // History Management
     //
     responseToHistoryItems(response) {
-        const anthropicResponse = response;
+        const bedrockResponse = response;
         const historyItems = [];
-        // Check if this is a tool use response
-        if (anthropicResponse.stop_reason === "tool_use") {
-            // Don't add to history yet - will be added after tool execution
+        if (bedrockResponse.stopReason === "tool_use") {
             return historyItems;
         }
-        // Include thinking blocks for extended thinking support
-        // Thinking blocks are preserved in history so extractReasoning can find them
-        for (const block of anthropicResponse.content) {
-            if (block.type === "thinking") {
-                // Push raw block - types are loosely checked at runtime
-                // This allows extractReasoning to access the thinking property
-                historyItems.push(block);
-            }
-        }
-        // Extract text content for non-tool responses
-        const textBlock = anthropicResponse.content.find((block) => block.type === "text");
+        const content = bedrockResponse.output?.message?.content ?? [];
+        const textBlock = content.find((block) => "text" in block);
         if (textBlock) {
             historyItems.push({
                 content: textBlock.text,
-                role: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+                role: "assistant",
                 type: exports.LlmMessageType.Message,
             });
         }
@@ -1243,8 +2470,10 @@ class AnthropicAdapter extends BaseProviderAdapter {
     //
     classifyError(error) {
         const errorName = error?.constructor?.name;
-        // Check for rate limit error
-        if (errorName === "RateLimitError") {
+        const errorMessage = error?.message ?? "";
+        if (errorName === "ThrottlingException" ||
+            errorMessage.includes("ThrottlingException") ||
+            errorMessage.includes("Too Many Requests")) {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -1252,23 +2481,34 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 suggestedDelayMs: 60000,
             };
         }
-        // Check for retryable errors
-        if (RETRYABLE_ERROR_NAMES.includes(errorName)) {
+        if (errorName === "ServiceUnavailableException" ||
+            errorName === "InternalServerException" ||
+            errorMessage.includes("ServiceUnavailableException") ||
+            errorMessage.includes("InternalServerException")) {
             return {
                 error,
                 category: ErrorCategory.Retryable,
                 shouldRetry: true,
             };
         }
-        // Check for non-retryable errors
-        if (NOT_RETRYABLE_ERROR_NAMES.includes(errorName)) {
+        if (errorName === "AccessDeniedException" ||
+            errorName === "ValidationException" ||
+            errorName === "ResourceNotFoundException" ||
+            errorMessage.includes("AccessDeniedException") ||
+            errorMessage.includes("ValidationException")) {
             return {
                 error,
                 category: ErrorCategory.Unrecoverable,
                 shouldRetry: false,
             };
         }
-        // Unknown error - treat as potentially retryable
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         return {
             error,
             category: ErrorCategory.Unknown,
@@ -1276,49 +2516,87 @@ class AnthropicAdapter extends BaseProviderAdapter {
         };
     }
     //
-    // Provider-Specific Features
+    // Structured Output
     //
-    isComplete(response) {
-        const anthropicResponse = response;
-        return anthropicResponse.stop_reason !== "tool_use";
-    }
     hasStructuredOutput(response) {
-        const anthropicResponse = response;
-        // Check if the last content block is a tool_use with structured_output
-        const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
-        return (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+        const bedrockResponse = response;
+        if (bedrockResponse.__jaypieStructuredOutput) {
+            return this.extractStructuredOutput(response) !== undefined;
+        }
+        // Fake-tool path: last content block is a structured_output toolUse
+        const content = (bedrockResponse.output?.message?.content ??
+            []);
+        const last = content[content.length - 1];
+        return (!!last &&
+            "toolUse" in last &&
+            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
     }
     extractStructuredOutput(response) {
-        const anthropicResponse = response;
-        const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
-        if (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
-            return lastBlock.input;
+        const bedrockResponse = response;
+        if (bedrockResponse.__jaypieStructuredOutput) {
+            const content = (bedrockResponse.output?.message?.content ??
+                []);
+            const textBlock = content.find((b) => "text" in b);
+            if (!textBlock)
+                return undefined;
+            return extractJson(textBlock.text);
+        }
+        // Fake-tool path
+        const content = (bedrockResponse.output?.message?.content ??
+            []);
+        const last = content[content.length - 1];
+        if (last &&
+            "toolUse" in last &&
+            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
+            return last.toolUse.input;
         }
         return undefined;
     }
     //
+    // Completion Detection
+    //
+    isComplete(response) {
+        const bedrockResponse = response;
+        return bedrockResponse.stopReason !== "tool_use";
+    }
+    //
     // Private Helpers
     //
-    extractContent(response) {
-        // Check for structured output first
-        if (this.hasStructuredOutput(response)) {
-            return this.extractStructuredOutput(response);
-        }
-        // Extract text content
-        const textBlock = response.content.find((block) => block.type === "text");
+    extractContentFromMessage(message) {
+        if (!message?.content)
+            return undefined;
+        const content = message.content;
+        const textBlock = content.find((block) => "text" in block);
         return textBlock?.text;
     }
 }
-// Export singleton instance
-const anthropicAdapter = new AnthropicAdapter();
+const bedrockAdapter = new BedrockAdapter();
 
 //
 //
 // 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 = [
@@ -1342,15 +2620,30 @@ const NOT_RETRYABLE_STATUS_CODES = [
 // Main
 //
 /**
- * GeminiAdapter implements the ProviderAdapter interface for Google's Gemini API.
+ * GoogleAdapter implements the ProviderAdapter interface for Google's Gemini API.
  * It handles request building, response parsing, and error classification
  * specific to Gemini's generateContent API.
  */
-class GeminiAdapter extends BaseProviderAdapter {
+class GoogleAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
-        this.name = PROVIDER.GEMINI.NAME;
-        this.defaultModel = PROVIDER.GEMINI.MODEL.DEFAULT;
+        this.name = PROVIDER.GOOGLE.NAME;
+        this.defaultModel = PROVIDER.GOOGLE.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
@@ -1379,9 +2672,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(`[GoogleAdapter] 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,
@@ -1391,21 +2702,33 @@ 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)) {
-            geminiRequest.config = {
-                ...geminiRequest.config,
-                responseMimeType: "application/json",
-                responseJsonSchema: request.format,
-            };
+        // 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,
+                    responseMimeType: "application/json",
+                    responseJsonSchema: request.format,
+                };
+            }
+            else {
+                geminiRequest.config = {
+                    ...geminiRequest.config,
+                    responseMimeType: "application/json",
+                    responseSchema: jsonSchemaToOpenApi3(request.format),
+                };
+            }
         }
-        // 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,
@@ -1430,8 +2753,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: {
@@ -1439,16 +2768,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;
@@ -1467,28 +2786,80 @@ class GeminiAdapter extends BaseProviderAdapter {
                 : naturalZodSchema(schema);
             jsonSchema = v4.z.toJSONSchema(zodSchema);
         }
-        // Remove $schema property (Gemini doesn't need it)
-        if (jsonSchema.$schema) {
-            delete jsonSchema.$schema;
-        }
-        return jsonSchema;
+        return jsonSchemaToOpenApi3(jsonSchema);
     }
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
-        // Cast config to any to bypass strict type checking between our internal types
-        // and the SDK's types. The SDK will validate at runtime.
-        const response = await genAI.models.generateContent({
-            model: geminiRequest.model,
-            contents: geminiRequest.contents,
-            config: geminiRequest.config,
-        });
-        return response;
+        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.
+            const response = await genAI.models.generateContent({
+                model: geminiRequest.model,
+                contents: geminiRequest.contents,
+                config: geminiRequest.config,
+            });
+            return response;
+        }
+        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(`[GoogleAdapter] 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) {
+    async *executeStreamRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
         // Use generateContentStream for streaming
@@ -1497,8 +2868,6 @@ class GeminiAdapter extends BaseProviderAdapter {
             contents: geminiRequest.contents,
             config: geminiRequest.config,
         });
-        // Track current function call being built
-        let currentFunctionCall = null;
         // Track usage for final chunk
         let inputTokens = 0;
         let outputTokens = 0;
@@ -1519,11 +2888,16 @@ class GeminiAdapter extends BaseProviderAdapter {
                     // Handle function calls
                     if (part.functionCall) {
                         const functionCall = part.functionCall;
-                        currentFunctionCall = {
+                        const currentFunctionCall = {
                             id: functionCall.id || this.generateCallId(),
                             name: functionCall.name || "",
                             arguments: functionCall.args || {},
                         };
+                        // Preserve thoughtSignature for Gemini 3 models
+                        // Required to maintain tool call context between turns
+                        const metadata = part.thoughtSignature
+                            ? { thoughtSignature: part.thoughtSignature }
+                            : undefined;
                         // Emit the function call immediately
                         yield {
                             type: exports.LlmStreamChunkType.ToolCall,
@@ -1531,9 +2905,9 @@ class GeminiAdapter extends BaseProviderAdapter {
                                 id: currentFunctionCall.id,
                                 name: currentFunctionCall.name,
                                 arguments: JSON.stringify(currentFunctionCall.arguments),
+                                metadata,
                             },
                         };
-                        currentFunctionCall = null;
                     }
                 }
             }
@@ -1620,14 +2994,24 @@ class GeminiAdapter extends BaseProviderAdapter {
     // Tool Result Handling
     //
     formatToolResult(toolCall, result) {
-        // Gemini expects the response to be the actual result object, not wrapped in "result"
-        // The output from StandardToolResult is JSON-stringified, so we need to parse it
+        // Gemini's `function_response.response` is a protobuf Struct, which only
+        // accepts plain objects. Some models (e.g. gemini-3.1-pro) accept scalar
+        // values silently; gemini-3.1-flash-lite rejects them. Parse the output
+        // and wrap any non-object value (string, number, boolean, array, null)
+        // in `{ result: value }` so every tool result is a valid Struct.
         let responseData;
         try {
-            responseData = JSON.parse(result.output);
+            const parsed = JSON.parse(result.output);
+            if (parsed !== null &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed)) {
+                responseData = parsed;
+            }
+            else {
+                responseData = { result: parsed };
+            }
         }
         catch {
-            // If parsing fails, wrap the output as a string result
             responseData = { result: result.output };
         }
         return {
@@ -1750,6 +3134,14 @@ class GeminiAdapter extends BaseProviderAdapter {
                 shouldRetry: true,
             };
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -1983,7 +3375,17 @@ class GeminiAdapter extends BaseProviderAdapter {
                 return JSON.parse(textContent);
             }
             catch {
-                // If parsing fails, return the original string
+                // Strip markdown code fences and retry (Gemini sometimes wraps JSON in fences)
+                const jsonMatch = textContent.match(/```(?:json)?\s*([\s\S]*?)\s*```/) ||
+                    textContent.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    try {
+                        return JSON.parse(jsonMatch[1] || jsonMatch[0]);
+                    }
+                    catch {
+                        // Fall through to return original string
+                    }
+                }
                 return textContent;
             }
         }
@@ -1994,7 +3396,7 @@ class GeminiAdapter extends BaseProviderAdapter {
     }
 }
 // Export singleton instance
-const geminiAdapter = new GeminiAdapter();
+const googleAdapter = new GoogleAdapter();
 
 // Patterns for OpenAI reasoning models that support extended thinking
 const REASONING_MODEL_PATTERNS = [
@@ -2026,6 +3428,27 @@ const NOT_RETRYABLE_ERROR_TYPES = [
     openai.RateLimitError,
     openai.UnprocessableEntityError,
 ];
+// Models known not to accept `temperature`.
+// Patterns (not exact names) so dated variants and future releases are covered
+// without code changes — OpenAI is removing temperature on newer reasoning
+// models.
+const MODELS_WITHOUT_TEMPERATURE$1 = [
+    /^gpt-5\.5/, // gpt-5.5 series deprecated temperature
+    /^o\d/, // o-series reasoning models (o1, o3, o4, ...)
+];
+function isTemperatureDeprecationError$1(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    if (!(error instanceof openai.BadRequestError) &&
+        error.status !== 400) {
+        return false;
+    }
+    const messages = [
+        error.message,
+        error.error?.message,
+    ].filter((m) => typeof m === "string");
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
 //
 //
 // Main
@@ -2040,6 +3463,20 @@ class OpenAiAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.OPENAI.NAME;
         this.defaultModel = PROVIDER.OPENAI.MODEL.DEFAULT;
+        // 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();
+    }
+    rememberModelRejectsTemperature(model) {
+        this.runtimeNoTemperatureModels.add(model);
+    }
+    clearRuntimeNoTemperatureModels() {
+        this.runtimeNoTemperatureModels.clear();
+    }
+    supportsTemperature(model) {
+        if (this.runtimeNoTemperatureModels.has(model))
+            return false;
+        return !MODELS_WITHOUT_TEMPERATURE$1.some((pattern) => pattern.test(model));
     }
     //
     // Request Building
@@ -2048,7 +3485,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
         const model = request.model || this.defaultModel;
         const openaiRequest = {
             model,
-            input: request.messages,
+            input: this.sanitizeInputItems(request.messages),
         };
         if (request.user) {
             openaiRequest.user = request.user;
@@ -2083,6 +3520,11 @@ class OpenAiAdapter extends BaseProviderAdapter {
         if (request.temperature !== undefined) {
             openaiRequest.temperature = request.temperature;
         }
+        // Strip temperature for models that don't support it (denylist + runtime cache)
+        if (openaiRequest.temperature !== undefined &&
+            !this.supportsTemperature(openaiRequest.model)) {
+            delete openaiRequest.temperature;
+        }
         return openaiRequest;
     }
     formatTools(toolkit, _outputSchema) {
@@ -2130,19 +3572,34 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const openai = client;
-        // @ts-expect-error OpenAI SDK types don't match our request format exactly
-        return await openai.responses.create(request);
+        const openaiRequest = request;
+        try {
+            return await openai.responses.create(openaiRequest, signal ? { signal } : undefined);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            // If the model rejected `temperature`, cache it and retry without the param
+            if (openaiRequest.temperature !== undefined &&
+                isTemperatureDeprecationError$1(error)) {
+                this.rememberModelRejectsTemperature(openaiRequest.model);
+                const retryRequest = { ...openaiRequest };
+                delete retryRequest.temperature;
+                return await openai.responses.create(retryRequest, signal ? { signal } : undefined);
+            }
+            throw error;
+        }
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const openai = client;
         const baseRequest = request;
         const streamRequest = {
             ...baseRequest,
             stream: true,
         };
-        const stream = await openai.responses.create(streamRequest);
+        const stream = await openai.responses.create(streamRequest, signal ? { signal } : undefined);
         // Track current function call being built
         let currentFunctionCall = null;
         // Track usage for final chunk
@@ -2192,6 +3649,9 @@ class OpenAiAdapter extends BaseProviderAdapter {
                             id: currentFunctionCall.callId,
                             name: currentFunctionCall.name,
                             arguments: currentFunctionCall.arguments,
+                            // Preserve the item ID (fc_...) separately from call_id (call_...)
+                            // OpenAI Responses API requires both with correct prefixes
+                            metadata: { itemId: currentFunctionCall.id },
                         },
                     };
                     currentFunctionCall = null;
@@ -2352,6 +3812,14 @@ class OpenAiAdapter extends BaseProviderAdapter {
                 };
             }
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -2378,6 +3846,31 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     // Private Helpers
     //
+    /**
+     * Sanitize history items for the OpenAI Responses API.
+     * Strips fields not accepted by specific item types (e.g., `name` on
+     * function_call_output items) to prevent 400 "Unknown parameter" errors.
+     */
+    sanitizeInputItems(messages) {
+        return messages.map((item) => {
+            const typedItem = item;
+            // function_call_output only accepts: type, call_id, output, id, status
+            if (typedItem.type === exports.LlmMessageType.FunctionCallOutput) {
+                const sanitized = {
+                    type: typedItem.type,
+                    call_id: typedItem.call_id,
+                    output: typedItem.output,
+                };
+                if (typedItem.id)
+                    sanitized.id = typedItem.id;
+                if (typedItem.status)
+                    sanitized.status = typedItem.status;
+                return sanitized;
+            }
+            // All other items pass through as-is
+            return item;
+        });
+    }
     hasToolCalls(response) {
         if (!response.output || !Array.isArray(response.output)) {
             return false;
@@ -2423,10 +3916,48 @@ 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));
+}
+// OpenRouter routes that don't accept `temperature`. Patterns match the
+// vendor-prefixed route id (e.g. `openai/gpt-5.5`) so dated variants are
+// covered without code changes.
+const MODELS_WITHOUT_TEMPERATURE = [
+    /^openai\/gpt-5\.5/,
+    /^openai\/o\d/,
+    /^anthropic\/claude-opus-4-[789]/,
+    /^anthropic\/claude-opus-[5-9]/,
+];
+function isTemperatureDeprecationError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.statusCode;
+    if (status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
 /**
- * Convert standardized content items to OpenRouter format
- * Note: OpenRouter does not support native file/image uploads.
- * Images and files are discarded with a warning.
+ * Convert standardized content items to OpenRouter format. Images become
+ * `image_url` parts and files become `file` parts; both pass through to
+ * OpenRouter which routes to the selected backend. Backends that don't
+ * support the modality 4xx — that's a model-capability mismatch, surfaced
+ * by the call rather than silently dropped here.
  */
 function convertContentToOpenRouter(content) {
     if (typeof content === "string") {
@@ -2434,25 +3965,38 @@ function convertContentToOpenRouter(content) {
     }
     const parts = [];
     for (const item of content) {
-        // Text content - pass through
         if (item.type === exports.LlmMessageType.InputText) {
             parts.push({ type: "text", text: item.text });
             continue;
         }
-        // Image content - warn and discard
         if (item.type === exports.LlmMessageType.InputImage) {
-            log$2.log.warn("OpenRouter does not support image uploads; image discarded");
+            const url = item.image_url ?? "";
+            if (!url) {
+                log$1.log.warn("OpenRouter image content missing image_url; image discarded");
+                continue;
+            }
+            parts.push({ type: "image_url", imageUrl: { url } });
             continue;
         }
-        // File/Document content - warn and discard
         if (item.type === exports.LlmMessageType.InputFile) {
-            log$2.log.warn({ filename: item.filename }, "OpenRouter does not support file uploads; file discarded");
+            const fileData = typeof item.file_data === "string" ? item.file_data : "";
+            if (!fileData) {
+                log$1.log.warn({ filename: item.filename }, "OpenRouter file content missing file_data; file discarded");
+                continue;
+            }
+            parts.push({
+                type: "file",
+                file: {
+                    filename: item.filename,
+                    fileData,
+                },
+            });
             continue;
         }
         // Unknown type - warn and skip
-        log$2.log.warn({ item }, "Unknown content type for OpenRouter; discarded");
+        log$1.log.warn({ item }, "Unknown content type for OpenRouter; discarded");
     }
-    // If no text parts remain, return empty string to avoid empty array
+    // If no parts remain, return empty string to avoid empty array
     if (parts.length === 0) {
         return "";
     }
@@ -2461,6 +4005,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
@@ -2476,6 +4046,33 @@ 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();
+        // Session-level cache of routes observed to reject `temperature`. Populated
+        // by executeRequest on 400 errors so repeat calls skip the param.
+        this.runtimeNoTemperatureModels = new Set();
+    }
+    rememberModelRejectsStructuredOutput(model) {
+        this.runtimeNoStructuredOutputModels.add(model);
+    }
+    clearRuntimeNoStructuredOutputModels() {
+        this.runtimeNoStructuredOutputModels.clear();
+    }
+    supportsStructuredOutput(model) {
+        return !this.runtimeNoStructuredOutputModels.has(model);
+    }
+    rememberModelRejectsTemperature(model) {
+        this.runtimeNoTemperatureModels.add(model);
+    }
+    clearRuntimeNoTemperatureModels() {
+        this.runtimeNoTemperatureModels.clear();
+    }
+    supportsTemperature(model) {
+        if (this.runtimeNoTemperatureModels.has(model))
+            return false;
+        return !MODELS_WITHOUT_TEMPERATURE.some((pattern) => pattern.test(model));
     }
     //
     // Request Building
@@ -2497,8 +4094,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,
@@ -2510,6 +4122,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);
         }
@@ -2518,26 +4143,26 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             openRouterRequest.temperature =
                 request.temperature;
         }
+        // Strip temperature for routes that don't support it (denylist + runtime cache)
+        const requestRecord = openRouterRequest;
+        if (requestRecord.temperature !== undefined &&
+            !this.supportsTemperature(openRouterRequest.model)) {
+            delete requestRecord.temperature;
+        }
         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;
@@ -2550,45 +4175,141 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             jsonSchema.type = "object"; // Normalize type
         }
         else {
-            // Convert NaturalSchema to JSON schema through Zod
+            // Convert NaturalSchema to JSON schema through Zod. Re-spread into a
+            // plain object: Zod v4's z.toJSONSchema returns an object that carries
+            // a non-configurable `~standard` Standard-Schema interop marker as a
+            // non-enumerable own property. Anthropic's output_config.format
+            // validation is strict and rejects unknown properties when OpenRouter
+            // forwards the schema, so we drop the marker here. JSON.stringify
+            // already skips it but the OpenRouter SDK enumerates own properties
+            // during serialization.
             const zodSchema = schema instanceof v4.z.ZodType
                 ? schema
                 : naturalZodSchema(schema);
-            jsonSchema = v4.z.toJSONSchema(zodSchema);
+            jsonSchema = { ...v4.z.toJSONSchema(zodSchema) };
         }
         // Remove $schema property (can cause issues with some providers)
         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;
     }
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
-        const response = await openRouter.chat.send({
+        const wantsStructuredOutput = Boolean(openRouterRequest.response_format);
+        try {
+            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 route rejected `temperature` (e.g., openai/gpt-5.5 forwarding),
+            // cache it and retry without the param.
+            const requestRecord = openRouterRequest;
+            if (requestRecord.temperature !== undefined &&
+                isTemperatureDeprecationError(error)) {
+                this.rememberModelRejectsTemperature(openRouterRequest.model);
+                const retryRequest = { ...openRouterRequest };
+                delete retryRequest.temperature;
+                const response = (await openRouter.chat.send(this.toSdkChatParams(retryRequest), signal ? { signal } : undefined));
+                if (wantsStructuredOutput) {
+                    response.__jaypieStructuredOutput = true;
+                }
+                return response;
+            }
+            // 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;
+        }
+    }
+    /**
+     * 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,
-        });
-        return response;
+        };
+        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) {
+    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({
-            model: openRouterRequest.model,
-            messages: openRouterRequest.messages,
-            tools: openRouterRequest.tools,
-            toolChoice: openRouterRequest.tool_choice,
-            user: openRouterRequest.user,
+        // 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,
-        });
+        };
+        const stream = (await openRouter.chat.send(streamParams, signal ? { signal } : undefined));
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -2838,6 +4559,14 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 suggestedDelayMs: 60000,
             };
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -2859,6 +4588,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) {
@@ -2870,6 +4606,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) {
@@ -2995,8 +4745,54 @@ 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.
+ * 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() {
+        super(...arguments);
+        // @ts-expect-error Narrowing override: xAI name differs from parent's literal "openai"
+        this.name = PROVIDER.XAI.NAME;
+        // @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();
+
 const DEFAULT_TOOL_TYPE = "function";
-const log = log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const log = log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
     log.trace.var({ [context.name]: message });
 }
@@ -3130,6 +4926,198 @@ class Toolkit {
     }
 }
 
+//
+//
+// Constants
+//
+const ENV = {
+    DD_LLMOBS_ENABLED: "DD_LLMOBS_ENABLED",
+};
+const MODULE = {
+    // Computed at runtime so bundlers (esbuild) do not attempt to include
+    // dd-trace, which is provided by the Datadog Lambda layer at runtime.
+    DD_TRACE: ["dd", "trace"].join("-"),
+};
+//
+//
+// Helpers
+//
+// CJS/ESM compatible require - handles bundling to CJS where import.meta.url
+// becomes undefined (mirrors packages/testkit/src/mock/original.ts).
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - __filename exists in CJS context when ESM is bundled to CJS
+const requireModule = typeof __filename !== "undefined"
+    ? module$1.createRequire(url.pathToFileURL(__filename).href)
+    : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+let resolved = false;
+let cachedSdk$4 = null;
+/**
+ * Lazily resolve the dd-trace `llmobs` SDK. Returns null (and never throws)
+ * when dd-trace is absent or the SDK surface is unexpected. Cached after the
+ * first attempt.
+ */
+function resolveLlmObs() {
+    if (resolved) {
+        return cachedSdk$4;
+    }
+    resolved = true;
+    try {
+        const ddTrace = requireModule(MODULE.DD_TRACE);
+        const tracer = ddTrace?.default ?? ddTrace;
+        const llmobs = tracer?.llmobs;
+        if (llmobs &&
+            typeof llmobs.trace === "function" &&
+            typeof llmobs.annotate === "function") {
+            cachedSdk$4 = llmobs;
+        }
+    }
+    catch {
+        cachedSdk$4 = null;
+    }
+    return cachedSdk$4;
+}
+//
+//
+// Main
+//
+/**
+ * True when LLM Observability emission is opted in via `DD_LLMOBS_ENABLED`.
+ * Accepts any truthy value except "false"/"0".
+ */
+function isLlmObsEnabled() {
+    const value = process.env[ENV.DD_LLMOBS_ENABLED];
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "false" && normalized !== "0";
+}
+/** Resolve the SDK only when enabled and available. */
+function activeSdk() {
+    if (!isLlmObsEnabled()) {
+        return null;
+    }
+    return resolveLlmObs();
+}
+/**
+ * Run `fn` inside an LLM Observability span. When emission is disabled or
+ * dd-trace is absent, `fn` is invoked directly with no overhead. The active
+ * span is established for the duration of `fn`, so nested `withLlmObsSpan`
+ * calls (and `annotateLlmObs`) attach as children/annotations automatically.
+ */
+async function withLlmObsSpan(options, fn) {
+    const sdk = activeSdk();
+    if (!sdk) {
+        return fn();
+    }
+    let started = false;
+    try {
+        return (await sdk.trace(options, () => {
+            started = true;
+            return fn();
+        }));
+    }
+    catch (error) {
+        // If `fn` ran, propagate its error (the SDK re-throws after finishing the
+        // span). Only swallow failures from the instrumentation itself, re-running
+        // `fn` so observability never breaks the underlying call.
+        if (started) {
+            throw error;
+        }
+        getLogger$6().warn("[llmobs] span emission failed");
+        getLogger$6().var({ error });
+        return fn();
+    }
+}
+/**
+ * Annotate the currently active LLM Observability span. No-op when disabled.
+ */
+function annotateLlmObs(annotation) {
+    const sdk = activeSdk();
+    if (!sdk) {
+        return;
+    }
+    try {
+        sdk.annotate(undefined, annotation);
+    }
+    catch (error) {
+        getLogger$6().warn("[llmobs] annotate failed");
+        getLogger$6().var({ error });
+    }
+}
+/**
+ * Open a manual span that is finished later. Used by streaming, where work is
+ * yielded incrementally and cannot be enclosed in a single callback. The span
+ * is kept open via a deferred promise resolved by `finish()`. Returns null when
+ * emission is disabled or dd-trace is absent.
+ *
+ * Note: because the span is held open across `yield` boundaries (outside the
+ * SDK's AsyncLocalStorage scope), manual spans are emitted flat rather than
+ * nested. Annotations are applied to the explicit span reference.
+ */
+function openLlmObsSpan(options) {
+    const sdk = activeSdk();
+    if (!sdk) {
+        return null;
+    }
+    try {
+        let capturedSpan;
+        let release;
+        const held = new Promise((resolve) => {
+            release = resolve;
+        });
+        // trace() runs the callback synchronously, capturing the span; the returned
+        // pending promise keeps the span open until finish() resolves it.
+        void sdk.trace(options, (span) => {
+            capturedSpan = span;
+            return held;
+        });
+        let finished = false;
+        return {
+            annotate: (annotation) => {
+                try {
+                    sdk.annotate(capturedSpan, annotation);
+                }
+                catch (error) {
+                    getLogger$6().warn("[llmobs] annotate failed");
+                    getLogger$6().var({ error });
+                }
+            },
+            finish: () => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                release?.();
+            },
+        };
+    }
+    catch (error) {
+        getLogger$6().warn("[llmobs] span emission failed");
+        getLogger$6().var({ error });
+        return null;
+    }
+}
+//
+//
+// Mapping Helpers
+//
+/**
+ * Sum an `LlmUsage` array into LLM Observability metric keys. Returns undefined
+ * when there is no usage data so callers can omit the `metrics` field.
+ */
+function usageToLlmObsMetrics(usage) {
+    if (!usage || usage.length === 0) {
+        return undefined;
+    }
+    const metrics = usage.reduce((sum, item) => ({
+        input_tokens: sum.input_tokens + (item.input ?? 0),
+        output_tokens: sum.output_tokens + (item.output ?? 0),
+        total_tokens: sum.total_tokens + (item.total ?? 0),
+    }), { input_tokens: 0, output_tokens: 0, total_tokens: 0 });
+    return metrics;
+}
+
 //
 //
 // Main
@@ -3776,6 +5764,78 @@ class RetryPolicy {
 // Export a default policy instance
 const defaultRetryPolicy = new RetryPolicy();
 
+//
+//
+// Helpers
+//
+/**
+ * Compare an unhandled rejection reason against errors the retry loop has
+ * already caught. Reference equality first, then fall back to message + name
+ * — providers sometimes surface twin rejections as fresh Error instances
+ * rebuilt from the same upstream failure.
+ */
+function matchesCaughtError(reason, caught) {
+    if (caught.has(reason))
+        return true;
+    if (!(reason instanceof Error))
+        return false;
+    for (const handled of caught) {
+        if (handled instanceof Error &&
+            handled.name === reason.name &&
+            handled.message === reason.message) {
+            return true;
+        }
+    }
+    return false;
+}
+//
+//
+// Main
+//
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+function createStaleRejectionGuard() {
+    const log = getLogger$6();
+    const caughtErrors = new Set();
+    let listener;
+    return {
+        install() {
+            if (listener)
+                return;
+            listener = (reason, promise) => {
+                if (isTransientNetworkError(reason)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed stale socket error during retry");
+                    return;
+                }
+                if (matchesCaughtError(reason, caughtErrors)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed sibling rejection of already-handled error");
+                }
+            };
+            process.on("unhandledRejection", listener);
+        },
+        remove() {
+            if (listener) {
+                process.removeListener("unhandledRejection", listener);
+                listener = undefined;
+            }
+            caughtErrors.clear();
+        },
+        recordCaught(error) {
+            caughtErrors.add(error);
+        },
+    };
+}
+
 //
 //
 // Main
@@ -3791,67 +5851,85 @@ class RetryExecutor {
         this.errorClassifier = config.errorClassifier;
     }
     /**
-     * Execute an operation with retry logic
+     * Execute an operation with retry logic.
+     * Each attempt receives an AbortSignal. On failure, the signal is aborted
+     * before sleeping — this kills lingering socket callbacks from the previous
+     * request and prevents stale async errors from escaping the retry loop.
      *
-     * @param operation - The async operation to execute
+     * @param operation - The async operation to execute (receives AbortSignal)
      * @param options - Execution options including context and hooks
      * @returns The result of the operation
      * @throws BadGatewayError if all retries are exhausted or error is not retryable
      */
     async execute(operation, options) {
+        const log = getLogger$6();
         let attempt = 0;
-        while (true) {
-            try {
-                const result = await operation();
-                if (attempt > 0) {
-                    log$1.debug(`API call succeeded after ${attempt} retries`);
-                }
-                return result;
-            }
-            catch (error) {
-                // Check if we've exhausted retries
-                if (!this.policy.shouldRetry(attempt)) {
-                    log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
-                        input: options.context.input,
-                        options: options.context.options,
-                        providerRequest: options.context.providerRequest,
-                        error,
-                    });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
+        // Guard against stale rejections firing on a subsequent microtask after
+        // the retry layer has already caught the originating error: undici socket
+        // teardown (TypeError: terminated) and twin upstream-SDK rejections
+        // (e.g. issue #336 — OpenRouter SyntaxError siblings).
+        const guard = createStaleRejectionGuard();
+        try {
+            while (true) {
+                const controller = new AbortController();
+                try {
+                    const result = await operation(controller.signal);
+                    if (attempt > 0) {
+                        log.debug(`API call succeeded after ${attempt} retries`);
+                    }
+                    return result;
                 }
-                // Check if error is not retryable
-                if (!this.errorClassifier.isRetryable(error)) {
-                    log$1.error("API call failed with non-retryable error");
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                catch (error) {
+                    controller.abort("retry");
+                    guard.recordCaught(error);
+                    guard.install();
+                    // Check if we've exhausted retries
+                    if (!this.policy.shouldRetry(attempt)) {
+                        log.error(`API call failed after ${this.policy.maxRetries} retries`);
+                        log.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Check if error is not retryable
+                    if (!this.errorClassifier.isRetryable(error)) {
+                        log.error("API call failed with non-retryable error");
+                        log.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Warn if this is an unknown error type
+                    if (!this.errorClassifier.isKnownError(error)) {
+                        log.warn("API returned unknown error type, will retry");
+                        log.var({ error });
+                    }
+                    const delay = this.policy.getDelayForAttempt(attempt);
+                    log.warn(`API call failed. Retrying in ${delay}ms...`);
+                    await this.hookRunner.runOnRetryableError(options.hooks, {
                         input: options.context.input,
                         options: options.context.options,
                         providerRequest: options.context.providerRequest,
                         error,
                     });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
-                }
-                // Warn if this is an unknown error type
-                if (!this.errorClassifier.isKnownError(error)) {
-                    log$1.warn("API returned unknown error type, will retry");
-                    log$1.var({ error });
+                    await kit.sleep(delay);
+                    attempt++;
                 }
-                const delay = this.policy.getDelayForAttempt(attempt);
-                log$1.warn(`API call failed. Retrying in ${delay}ms...`);
-                await this.hookRunner.runOnRetryableError(options.hooks, {
-                    input: options.context.input,
-                    options: options.context.options,
-                    providerRequest: options.context.providerRequest,
-                    error,
-                });
-                await kit.sleep(delay);
-                attempt++;
             }
         }
+        finally {
+            guard.remove();
+        }
     }
 }
 
@@ -3862,6 +5940,7 @@ class RetryExecutor {
 const ERROR$1 = {
     BAD_FUNCTION_CALL: "Bad Function Call",
 };
+const MAX_CONSECUTIVE_TOOL_ERRORS = 6;
 //
 //
 // Helpers
@@ -3902,37 +5981,54 @@ class OperateLoop {
      * Execute the operate loop for multi-turn conversations with tool calling.
      */
     async execute(input, options = {}) {
+        const log = getLogger$6();
         // Log what was passed to operate
-        log$1.trace("[operate] Starting operate loop");
-        log$1.var({ "operate.input": input });
-        log$1.var({ "operate.options": options });
+        log.trace("[operate] Starting operate loop");
+        log.var({ "operate.input": input });
+        log.var({ "operate.options": options });
         // Initialize state
         const state = await this.initializeState(input, options);
         const context = this.createContext(options);
-        // Build initial request
-        let request = this.buildInitialRequest(state, options);
-        // Multi-turn loop
-        while (state.currentTurn < state.maxTurns) {
-            state.currentTurn++;
-            // Execute one turn with retry logic
-            const shouldContinue = await this.executeOneTurn(request, state, context, options);
-            if (!shouldContinue) {
-                break;
+        const modelName = options.model ?? this.adapter.defaultModel;
+        // Enclosing LLM Observability span (no-op when DD_LLMOBS_ENABLED is unset).
+        // Child llm/tool spans nest under it via the SDK's active-span context.
+        return withLlmObsSpan({
+            kind: state.toolkit ? "agent" : "llm",
+            modelName,
+            modelProvider: this.adapter.name,
+            name: "jaypie.llm.operate",
+        }, async () => {
+            // Build initial request
+            let request = this.buildInitialRequest(state, options);
+            // Multi-turn loop
+            while (state.currentTurn < state.maxTurns) {
+                state.currentTurn++;
+                // Execute one turn with retry logic
+                const shouldContinue = await this.executeOneTurn(request, state, context, options);
+                if (!shouldContinue) {
+                    break;
+                }
+                // Rebuild request with updated history for next turn
+                request = {
+                    format: state.formattedFormat,
+                    instructions: options.instructions,
+                    messages: state.currentInput,
+                    model: modelName,
+                    providerOptions: options.providerOptions,
+                    system: options.system,
+                    temperature: options.temperature,
+                    tools: state.formattedTools,
+                    user: options.user,
+                };
             }
-            // Rebuild request with updated history for next turn
-            request = {
-                format: state.formattedFormat,
-                instructions: options.instructions,
-                messages: state.currentInput,
-                model: options.model ?? this.adapter.defaultModel,
-                providerOptions: options.providerOptions,
-                system: options.system,
-                temperature: options.temperature,
-                tools: state.formattedTools,
-                user: options.user,
-            };
-        }
-        return state.responseBuilder.build();
+            const response = state.responseBuilder.build();
+            annotateLlmObs({
+                inputData: input,
+                metrics: usageToLlmObsMetrics(response.usage),
+                outputData: response.content,
+            });
+            return response;
+        });
     }
     //
     // Private Methods
@@ -3984,6 +6080,7 @@ class OperateLoop {
             }
         }
         return {
+            consecutiveToolErrors: 0,
             currentInput: processedInput.history,
             currentTurn: 0,
             formattedFormat,
@@ -4013,6 +6110,7 @@ class OperateLoop {
         };
     }
     async executeOneTurn(request, state, context, options) {
+        const log = getLogger$6();
         // Create error classifier from adapter
         const errorClassifier = createErrorClassifier(this.adapter);
         // Create retry executor for this turn
@@ -4024,28 +6122,42 @@ class OperateLoop {
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
         // Log what was passed to the model
-        log$1.trace("[operate] Calling model");
-        log$1.var({ "operate.request": providerRequest });
+        log.trace("[operate] Calling model");
+        log.var({ "operate.request": providerRequest });
         // Execute beforeEachModelRequest hook
         await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
             input: state.currentInput,
             options,
             providerRequest,
         });
-        // Execute with retry (RetryExecutor handles error hooks and throws appropriate errors)
-        const response = await retryExecutor.execute(() => this.adapter.executeRequest(this.client, providerRequest), {
-            context: {
-                input: state.currentInput,
-                options,
-                providerRequest,
-            },
-            hooks: context.hooks,
+        // Execute with retry inside a child llm span (no-op when llmobs disabled).
+        // RetryExecutor handles error hooks and throws appropriate errors.
+        const { parsed, response } = await withLlmObsSpan({
+            kind: "llm",
+            modelName: options.model ?? this.adapter.defaultModel,
+            modelProvider: this.adapter.name,
+            name: "jaypie.llm.model",
+        }, async () => {
+            const response = await retryExecutor.execute((signal) => this.adapter.executeRequest(this.client, providerRequest, signal), {
+                context: {
+                    input: state.currentInput,
+                    options,
+                    providerRequest,
+                },
+                hooks: context.hooks,
+            });
+            // Log what was returned from the model
+            log.trace("[operate] Model response received");
+            log.var({ "operate.response": response });
+            // Parse response
+            const parsed = this.adapter.parseResponse(response, options);
+            annotateLlmObs({
+                inputData: state.currentInput,
+                metrics: usageToLlmObsMetrics(parsed.usage ? [parsed.usage] : undefined),
+                outputData: parsed.content ?? "",
+            });
+            return { parsed, response };
         });
-        // Log what was returned from the model
-        log$1.trace("[operate] Model response received");
-        log$1.var({ "operate.response": response });
-        // Parse response
-        const parsed = this.adapter.parseResponse(response, options);
         // Track usage
         if (parsed.usage) {
             state.responseBuilder.addUsage(parsed.usage);
@@ -4066,7 +6178,7 @@ class OperateLoop {
         if (this.adapter.hasStructuredOutput(response)) {
             const structuredOutput = this.adapter.extractStructuredOutput(response);
             if (structuredOutput) {
-                state.responseBuilder.setContent(structuredOutput);
+                state.responseBuilder.setContent(this.applyFormatArrayDefaults(structuredOutput, options));
                 state.responseBuilder.complete();
                 return false; // Stop loop
             }
@@ -4090,11 +6202,19 @@ class OperateLoop {
                             args: toolCall.arguments,
                             toolName: toolCall.name,
                         });
-                        // Call the tool
-                        log$1.trace(`[operate] Calling tool - ${toolCall.name}`);
-                        const result = await state.toolkit.call({
-                            arguments: toolCall.arguments,
-                            name: toolCall.name,
+                        // Call the tool inside a child tool span (no-op when disabled)
+                        log.trace(`[operate] Calling tool - ${toolCall.name}`);
+                        const result = await withLlmObsSpan({ kind: "tool", name: toolCall.name }, async () => {
+                            const result = await state.toolkit.call({
+                                arguments: toolCall.arguments,
+                                name: toolCall.name,
+                            });
+                            annotateLlmObs({
+                                inputData: toolCall.arguments,
+                                metadata: { tool: toolCall.name },
+                                outputData: result,
+                            });
+                            return result;
                         });
                         // Execute afterEachTool hook
                         await this.hookRunnerInstance.runAfterTool(context.hooks, {
@@ -4108,6 +6228,8 @@ class OperateLoop {
                             output: JSON.stringify(result),
                             success: true,
                         };
+                        // Reset consecutive error counter on success
+                        state.consecutiveToolErrors = 0;
                         // Update provider request with tool result
                         currentProviderRequest = this.adapter.appendToolResult(currentProviderRequest, toolCall, formattedResult);
                         // Sync state from updated request
@@ -4134,15 +6256,41 @@ class OperateLoop {
                             status: jaypieError.status,
                             title: ERROR$1.BAD_FUNCTION_CALL,
                         });
-                        log$1.error(`Error executing function call ${toolCall.name}`);
-                        log$1.var({ error });
+                        // Add error tool_result to history so the tool_use block is not orphaned.
+                        // Without this, the next turn's request would have a tool_use without a
+                        // matching tool_result, causing Anthropic API to reject with 400.
+                        const errorResult = {
+                            callId: toolCall.callId,
+                            output: JSON.stringify({
+                                error: error.message || "Tool execution failed",
+                            }),
+                            success: false,
+                            error: error.message,
+                        };
+                        const toolResultFormatted = this.adapter.formatToolResult(toolCall, errorResult);
+                        state.responseBuilder.appendToHistory(toolResultFormatted);
+                        log.warn(`Error executing function call ${toolCall.name}`);
+                        log.var({ error });
+                        // Track consecutive errors and stop if threshold reached
+                        state.consecutiveToolErrors++;
+                        if (state.consecutiveToolErrors >= MAX_CONSECUTIVE_TOOL_ERRORS) {
+                            const detail = `Stopped after ${MAX_CONSECUTIVE_TOOL_ERRORS} consecutive tool errors`;
+                            log.warn(detail);
+                            state.responseBuilder.setError({
+                                detail,
+                                status: 502,
+                                title: ERROR$1.BAD_FUNCTION_CALL,
+                            });
+                            state.responseBuilder.incomplete();
+                            return false; // Stop loop
+                        }
                     }
                 }
                 // Check if we've reached max turns
                 if (state.currentTurn >= state.maxTurns) {
                     const error = new errors.TooManyRequestsError();
                     const detail = `Model requested function call but exceeded ${state.maxTurns} turns`;
-                    log$1.warn(detail);
+                    log.warn(detail);
                     state.responseBuilder.setError({
                         detail,
                         status: error.status,
@@ -4155,7 +6303,7 @@ class OperateLoop {
             }
         }
         // No tool calls or no toolkit - we're done
-        state.responseBuilder.setContent(parsed.content);
+        state.responseBuilder.setContent(this.applyFormatArrayDefaults(parsed.content, options));
         state.responseBuilder.complete();
         // Add final history items
         const historyItems = this.adapter.responseToHistoryItems(parsed.raw);
@@ -4164,6 +6312,20 @@ class OperateLoop {
         }
         return false; // Stop loop
     }
+    /**
+     * Backfill declared array fields when a `format` is supplied. A declared
+     * `format` is a schema contract: an empty array field should surface as `[]`
+     * rather than be dropped by a provider/model that omits empty lists.
+     */
+    applyFormatArrayDefaults(content, options) {
+        if (!options.format) {
+            return content;
+        }
+        if (typeof content !== "object" || content === null) {
+            return content;
+        }
+        return fillFormatArrays({ content, format: options.format });
+    }
     /**
      * Sync the current input state from the updated provider request.
      * This is necessary because appendToolResult modifies the provider-specific request,
@@ -4289,12 +6451,14 @@ class StreamLoop {
         this.client = config.client;
         this.hookRunnerInstance = config.hookRunner ?? hookRunner;
         this.inputProcessorInstance = config.inputProcessor ?? inputProcessor;
+        this.retryPolicy = config.retryPolicy ?? defaultRetryPolicy;
     }
     /**
      * Execute the streaming loop for multi-turn conversations with tool calling.
      * Yields stream chunks as they become available.
      */
     async *execute(input, options = {}) {
+        const log = getLogger$6();
         // Verify adapter supports streaming
         if (!this.adapter.executeStreamRequest) {
             throw new errors.BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
@@ -4314,12 +6478,12 @@ class StreamLoop {
             }
             // If we have tool calls, process them
             if (toolCalls && toolCalls.length > 0 && state.toolkit) {
-                yield* this.processToolCalls(toolCalls, state, context, options);
+                yield* this.processToolCalls(toolCalls, state, context);
                 // Check if we've reached max turns
                 if (state.currentTurn >= state.maxTurns) {
                     const error = new errors.TooManyRequestsError();
                     const detail = `Model requested function call but exceeded ${state.maxTurns} turns`;
-                    log$1.warn(detail);
+                    log.warn(detail);
                     yield {
                         type: exports.LlmStreamChunkType.Error,
                         error: {
@@ -4382,6 +6546,7 @@ class StreamLoop {
             ? this.adapter.formatTools(toolkit, formattedFormat)
             : undefined;
         return {
+            consecutiveToolErrors: 0,
             currentInput: processedInput.history,
             currentTurn: 0,
             formattedFormat,
@@ -4411,6 +6576,7 @@ class StreamLoop {
         };
     }
     async *executeOneStreamingTurn(request, state, context, options) {
+        const log = getLogger$6();
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
         // Execute beforeEachModelRequest hook
@@ -4419,34 +6585,117 @@ class StreamLoop {
             options,
             providerRequest,
         });
+        // Open a manual llm span held open across the streamed turn. Flat (not
+        // nested) because it spans yield boundaries; no-op when llmobs disabled.
+        const llmSpan = openLlmObsSpan({
+            kind: "llm",
+            modelName: options.model ?? this.adapter.defaultModel,
+            modelProvider: this.adapter.name,
+            name: "jaypie.llm.model",
+        });
+        const inputSnapshot = [...state.currentInput];
+        let streamedText = "";
         // Collect tool calls from the stream
         const collectedToolCalls = [];
-        // Execute streaming request
-        const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest);
-        for await (const chunk of streamGenerator) {
-            // Pass through text chunks
-            if (chunk.type === exports.LlmStreamChunkType.Text) {
-                yield chunk;
-            }
-            // Collect tool calls
-            if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
-                collectedToolCalls.push({
-                    callId: chunk.toolCall.id,
-                    name: chunk.toolCall.name,
-                    arguments: chunk.toolCall.arguments,
-                    raw: chunk.toolCall,
-                });
-                yield chunk;
-            }
-            // Track usage from done chunk (but don't yield it yet - we'll emit our own)
-            if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
-                state.usageItems.push(...chunk.usage);
-            }
-            // Pass through error chunks
-            if (chunk.type === exports.LlmStreamChunkType.Error) {
-                yield chunk;
+        // Retry loop for connection-level failures
+        let attempt = 0;
+        let chunksYielded = false;
+        // Guard against stale rejections firing after the stream loop has already
+        // caught the originating error: undici socket teardown and twin
+        // upstream-SDK rejections (issue #336).
+        const guard = createStaleRejectionGuard();
+        try {
+            while (true) {
+                const controller = new AbortController();
+                try {
+                    // Execute streaming request
+                    const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest, controller.signal);
+                    for await (const chunk of streamGenerator) {
+                        // Pass through text chunks
+                        if (chunk.type === exports.LlmStreamChunkType.Text) {
+                            chunksYielded = true;
+                            streamedText += chunk.content ?? "";
+                            yield chunk;
+                        }
+                        // Collect tool calls
+                        if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
+                            chunksYielded = true;
+                            collectedToolCalls.push({
+                                callId: chunk.toolCall.id,
+                                name: chunk.toolCall.name,
+                                arguments: chunk.toolCall.arguments,
+                                raw: chunk.toolCall,
+                            });
+                            yield chunk;
+                        }
+                        // Track usage from done chunk (but don't yield it yet - we'll emit our own)
+                        if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
+                            state.usageItems.push(...chunk.usage);
+                        }
+                        // Pass through error chunks
+                        if (chunk.type === exports.LlmStreamChunkType.Error) {
+                            chunksYielded = true;
+                            yield chunk;
+                        }
+                    }
+                    // Stream completed successfully
+                    if (attempt > 0) {
+                        log.debug(`Stream request succeeded after ${attempt} retries`);
+                    }
+                    break;
+                }
+                catch (error) {
+                    controller.abort("retry");
+                    guard.recordCaught(error);
+                    guard.install();
+                    // If chunks were already yielded, we can't transparently retry
+                    if (chunksYielded) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        log.error("Stream failed after partial data was delivered");
+                        log.var({ error });
+                        yield {
+                            type: exports.LlmStreamChunkType.Error,
+                            error: {
+                                detail: errorMessage,
+                                status: 502,
+                                title: "Stream Error",
+                            },
+                        };
+                        llmSpan?.annotate({
+                            inputData: inputSnapshot,
+                            metrics: usageToLlmObsMetrics(state.usageItems),
+                            outputData: streamedText,
+                        });
+                        llmSpan?.finish();
+                        return { shouldContinue: false };
+                    }
+                    // Check if we've exhausted retries or error is not retryable
+                    if (!this.retryPolicy.shouldRetry(attempt) ||
+                        !this.adapter.isRetryableError(error)) {
+                        log.error(`Stream request failed after ${this.retryPolicy.maxRetries} retries`);
+                        log.var({ error });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        llmSpan?.finish();
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    const delay = this.retryPolicy.getDelayForAttempt(attempt);
+                    log.warn(`Stream request failed. Retrying in ${delay}ms...`);
+                    log.var({ error });
+                    await kit.sleep(delay);
+                    attempt++;
+                }
             }
         }
+        finally {
+            guard.remove();
+        }
+        // Annotate and finish the streamed llm span (no-op when disabled)
+        llmSpan?.annotate({
+            inputData: inputSnapshot,
+            metrics: usageToLlmObsMetrics(state.usageItems),
+            outputData: streamedText,
+        });
+        llmSpan?.finish();
         // Execute afterEachModelResponse hook
         await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
             content: "",
@@ -4460,19 +6709,29 @@ class StreamLoop {
         if (collectedToolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
             // Add tool calls to history
             for (const toolCall of collectedToolCalls) {
-                state.currentInput.push({
+                // Extract provider-specific metadata from the stream chunk
+                const metadata = toolCall.raw?.metadata;
+                const historyItem = {
                     type: exports.LlmMessageType.FunctionCall,
                     name: toolCall.name,
                     arguments: toolCall.arguments,
                     call_id: toolCall.callId,
-                    id: toolCall.callId,
-                });
+                    // Use provider item ID if available (e.g., OpenAI fc_... prefix),
+                    // otherwise fall back to callId
+                    id: metadata?.itemId || toolCall.callId,
+                };
+                // Preserve provider-specific fields (e.g., Gemini thoughtSignature)
+                if (metadata?.thoughtSignature) {
+                    historyItem.thoughtSignature = metadata.thoughtSignature;
+                }
+                state.currentInput.push(historyItem);
             }
             return { shouldContinue: true, toolCalls: collectedToolCalls };
         }
         return { shouldContinue: false };
     }
-    async *processToolCalls(toolCalls, state, context, _options) {
+    async *processToolCalls(toolCalls, state, context) {
+        const log = getLogger$6();
         for (const toolCall of toolCalls) {
             try {
                 // Execute beforeEachTool hook
@@ -4480,11 +6739,19 @@ class StreamLoop {
                     args: toolCall.arguments,
                     toolName: toolCall.name,
                 });
-                // Call the tool
-                log$1.trace(`[stream] Calling tool - ${toolCall.name}`);
-                const result = await state.toolkit.call({
-                    arguments: toolCall.arguments,
-                    name: toolCall.name,
+                // Call the tool inside a child tool span (no-op when disabled)
+                log.trace(`[stream] Calling tool - ${toolCall.name}`);
+                const result = await withLlmObsSpan({ kind: "tool", name: toolCall.name }, async () => {
+                    const result = await state.toolkit.call({
+                        arguments: toolCall.arguments,
+                        name: toolCall.name,
+                    });
+                    annotateLlmObs({
+                        inputData: toolCall.arguments,
+                        metadata: { tool: toolCall.name },
+                        outputData: result,
+                    });
+                    return result;
                 });
                 // Execute afterEachTool hook
                 await this.hookRunnerInstance.runAfterTool(context.hooks, {
@@ -4492,6 +6759,8 @@ class StreamLoop {
                     result,
                     toolName: toolCall.name,
                 });
+                // Reset consecutive error counter on success
+                state.consecutiveToolErrors = 0;
                 // Yield tool result chunk
                 yield {
                     type: exports.LlmStreamChunkType.ToolResult,
@@ -4530,8 +6799,35 @@ class StreamLoop {
                         title: ERROR.BAD_FUNCTION_CALL,
                     },
                 };
-                log$1.error(`Error executing function call ${toolCall.name}`);
-                log$1.var({ error });
+                // Add error tool_result to history so the tool_use block is not orphaned.
+                // Without this, the next turn's request would have a tool_use without a
+                // matching tool_result, causing Anthropic API to reject with 400.
+                const errorOutput = JSON.stringify({
+                    error: error.message || "Tool execution failed",
+                });
+                state.currentInput.push({
+                    type: exports.LlmMessageType.FunctionCallOutput,
+                    output: errorOutput,
+                    call_id: toolCall.callId,
+                    name: toolCall.name,
+                });
+                log.warn(`Error executing function call ${toolCall.name}`);
+                log.var({ error });
+                // Track consecutive errors and stop if threshold reached
+                state.consecutiveToolErrors++;
+                if (state.consecutiveToolErrors >= MAX_CONSECUTIVE_TOOL_ERRORS) {
+                    const stopDetail = `Stopped after ${MAX_CONSECUTIVE_TOOL_ERRORS} consecutive tool errors`;
+                    log.warn(stopDetail);
+                    yield {
+                        type: exports.LlmStreamChunkType.Error,
+                        error: {
+                            detail: stopDetail,
+                            status: 502,
+                            title: ERROR.BAD_FUNCTION_CALL,
+                        },
+                    };
+                    return; // Stop processing tools
+                }
             }
         }
     }
@@ -4589,28 +6885,28 @@ function createStreamLoop(config) {
 }
 
 // SDK loader with caching
-let cachedSdk$2 = null;
-async function loadSdk$2() {
-    if (cachedSdk$2)
-        return cachedSdk$2;
+let cachedSdk$3 = null;
+async function loadSdk$3() {
+    if (cachedSdk$3)
+        return cachedSdk$3;
     try {
-        cachedSdk$2 = await import('@anthropic-ai/sdk');
-        return cachedSdk$2;
+        cachedSdk$3 = await import('@anthropic-ai/sdk');
+        return cachedSdk$3;
     }
     catch {
         throw new errors.ConfigurationError("@anthropic-ai/sdk is required but not installed. Run: npm install @anthropic-ai/sdk");
     }
 }
 // Logger
-const getLogger$3 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$5 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$3({ apiKey, } = {}) {
-    const logger = getLogger$3();
+async function initializeClient$5({ apiKey, } = {}) {
+    const logger = getLogger$5();
     const resolvedApiKey = apiKey || (await aws.getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
     }
-    const sdk = await loadSdk$2();
+    const sdk = await loadSdk$3();
     const client = new sdk.default({ apiKey: resolvedApiKey });
     logger.trace("Initialized Anthropic client");
     return client;
@@ -4631,7 +6927,7 @@ function formatUserMessage$3(message, { data, placeholders } = {}) {
     };
 }
 function prepareMessages$3(message, { data, placeholders } = {}) {
-    const logger = getLogger$3();
+    const logger = getLogger$5();
     const messages = [];
     // Add user message (necessary for all requests)
     const userMessage = formatUserMessage$3(message, { data, placeholders });
@@ -4641,7 +6937,7 @@ function prepareMessages$3(message, { data, placeholders } = {}) {
 }
 // Basic text completion
 async function createTextCompletion$1(client, messages, model, systemMessage) {
-    log$2.log.trace("Using text output (unstructured)");
+    log$1.log.trace("Using text output (unstructured)");
     const params = {
         model,
         messages,
@@ -4650,63 +6946,58 @@ async function createTextCompletion$1(client, messages, model, systemMessage) {
     // Add system instruction if provided
     if (systemMessage) {
         params.system = systemMessage;
-        log$2.log.trace(`System message: ${systemMessage.length} characters`);
+        log$1.log.trace(`System message: ${systemMessage.length} characters`);
     }
     const response = await client.messages.create(params);
     const firstContent = response.content[0];
     const text = firstContent && "text" in firstContent ? firstContent.text : "";
-    log$2.log.trace(`Assistant reply: ${text.length} characters`);
+    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$2.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$2.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$2.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
@@ -4720,7 +7011,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$3();
+        this.log = getLogger$5();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -4729,7 +7020,7 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$3({ apiKey: this.apiKey });
+        this._client = await initializeClient$5({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -4804,6 +7095,87 @@ class AnthropicProvider {
     }
 }
 
+let cachedSdk$2 = null;
+async function loadSdk$2() {
+    if (cachedSdk$2)
+        return cachedSdk$2;
+    try {
+        cachedSdk$2 = await import('@aws-sdk/client-bedrock-runtime');
+        return cachedSdk$2;
+    }
+    catch {
+        throw new errors.ConfigurationError("@aws-sdk/client-bedrock-runtime is required but not installed. Run: npm install @aws-sdk/client-bedrock-runtime");
+    }
+}
+const getLogger$4 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+async function initializeClient$4({ region, } = {}) {
+    const logger = getLogger$4();
+    const resolvedRegion = region || process.env.AWS_REGION || "us-east-1";
+    const sdk = await loadSdk$2();
+    const client = new sdk.BedrockRuntimeClient({ region: resolvedRegion });
+    logger.trace("Initialized Bedrock client");
+    return client;
+}
+
+class BedrockProvider {
+    constructor(model = PROVIDER.BEDROCK.MODEL.DEFAULT, { region } = {}) {
+        this.log = getLogger$4();
+        this.conversationHistory = [];
+        this.model = model;
+        this.region = region;
+    }
+    async getClient() {
+        if (this._client)
+            return this._client;
+        this._client = await initializeClient$4({ region: this.region });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop)
+            return this._operateLoop;
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({ adapter: bedrockAdapter, client });
+        return this._operateLoop;
+    }
+    async getStreamLoop() {
+        if (this._streamLoop)
+            return this._streamLoop;
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({ adapter: bedrockAdapter, client });
+        return this._streamLoop;
+    }
+    async send(message, options) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options?.model ?? this.model };
+        const response = await operateLoop.execute(message, mergedOptions);
+        return response.content ?? "";
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        const response = await operateLoop.execute(input, mergedOptions);
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        yield* streamLoop.execute(input, mergedOptions);
+    }
+}
+
 // SDK loader with caching
 let cachedSdk$1 = null;
 async function loadSdk$1() {
@@ -4818,10 +7190,10 @@ async function loadSdk$1() {
     }
 }
 // Logger
-const getLogger$2 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$3 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$2({ apiKey, } = {}) {
-    const logger = getLogger$2();
+async function initializeClient$3({ apiKey, } = {}) {
+    const logger = getLogger$3();
     const resolvedApiKey = apiKey || (await aws.getEnvSecret("GEMINI_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -4841,21 +7213,20 @@ function formatUserMessage$2(message, { data, placeholders } = {}) {
     };
 }
 function prepareMessages$2(message, { data, placeholders } = {}) {
-    const logger = getLogger$2();
+    const logger = getLogger$3();
     const messages = [];
-    let systemInstruction;
     // Note: Gemini handles system prompts differently via systemInstruction config
     // This function is kept for compatibility but system prompts should be passed
     // via the systemInstruction parameter in generateContent
     const userMessage = formatUserMessage$2(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content?.length} characters`);
-    return { messages, systemInstruction };
+    return { messages, systemInstruction: undefined };
 }
 
-class GeminiProvider {
-    constructor(model = PROVIDER.GEMINI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$2();
+class GoogleProvider {
+    constructor(model = PROVIDER.GOOGLE.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger$3();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -4864,7 +7235,7 @@ class GeminiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$2({ apiKey: this.apiKey });
+        this._client = await initializeClient$3({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -4873,7 +7244,7 @@ class GeminiProvider {
         }
         const client = await this.getClient();
         this._operateLoop = createOperateLoop({
-            adapter: geminiAdapter,
+            adapter: googleAdapter,
             client,
         });
         return this._operateLoop;
@@ -4884,7 +7255,7 @@ class GeminiProvider {
         }
         const client = await this.getClient();
         this._streamLoop = createStreamLoop({
-            adapter: geminiAdapter,
+            adapter: googleAdapter,
             client,
         });
         return this._streamLoop;
@@ -4920,6 +7291,17 @@ class GeminiProvider {
                 return JSON.parse(text);
             }
             catch {
+                // Strip markdown code fences and retry (Gemini sometimes wraps JSON in fences)
+                const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/) ||
+                    text.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    try {
+                        return JSON.parse(jsonMatch[1] || jsonMatch[0]);
+                    }
+                    catch {
+                        // Fall through to return original text
+                    }
+                }
                 return text || "";
             }
         }
@@ -4958,10 +7340,10 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger$1 = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$2 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$1({ apiKey, } = {}) {
-    const logger = getLogger$1();
+async function initializeClient$2({ apiKey, } = {}) {
+    const logger = getLogger$2();
     const resolvedApiKey = apiKey || (await aws.getEnvSecret("OPENAI_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -4989,7 +7371,7 @@ function formatUserMessage$1(message, { data, placeholders } = {}) {
     };
 }
 function prepareMessages$1(message, { system, data, placeholders } = {}) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     const messages = [];
     if (system) {
         const systemMessage = formatSystemMessage$1(system, { data, placeholders });
@@ -5003,7 +7385,7 @@ function prepareMessages$1(message, { system, data, placeholders } = {}) {
 }
 // Completion requests
 async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     logger.trace("Using structured output");
     const zodSchema = responseSchema instanceof v4.z.ZodType
         ? responseSchema
@@ -5034,7 +7416,7 @@ async function createStructuredCompletion(client, { messages, responseSchema, mo
     return completion.choices[0].message.parsed;
 }
 async function createTextCompletion(client, { messages, model, }) {
-    const logger = getLogger$1();
+    const logger = getLogger$2();
     logger.trace("Using text output (unstructured)");
     const completion = await client.chat.completions.create({
         messages,
@@ -5046,7 +7428,7 @@ async function createTextCompletion(client, { messages, model, }) {
 
 class OpenAiProvider {
     constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$1();
+        this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5055,7 +7437,7 @@ class OpenAiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$1({ apiKey: this.apiKey });
+        this._client = await initializeClient$2({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5142,10 +7524,10 @@ async function loadSdk() {
     }
 }
 // Logger
-const getLogger = () => log$2.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$1 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient({ apiKey, } = {}) {
-    const logger = getLogger();
+async function initializeClient$1({ apiKey, } = {}) {
+    const logger = getLogger$1();
     const resolvedApiKey = apiKey || (await aws.getEnvSecret("OPENROUTER_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the requested keys");
@@ -5178,7 +7560,7 @@ function formatUserMessage(message, { data, placeholders } = {}) {
     };
 }
 function prepareMessages(message, { system, data, placeholders } = {}) {
-    const logger = getLogger();
+    const logger = getLogger$1();
     const messages = [];
     if (system) {
         const systemMessage = formatSystemMessage(system, { data, placeholders });
@@ -5193,7 +7575,7 @@ function prepareMessages(message, { system, data, placeholders } = {}) {
 
 class OpenRouterProvider {
     constructor(model = getDefaultModel(), { apiKey } = {}) {
-        this.log = getLogger();
+        this.log = getLogger$1();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5202,7 +7584,7 @@ class OpenRouterProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient({ apiKey: this.apiKey });
+        this._client = await initializeClient$1({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -5290,11 +7672,116 @@ class OpenRouterProvider {
     }
 }
 
+// Logger
+const getLogger = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret(PROVIDER.XAI.API_KEY));
+    if (!resolvedApiKey) {
+        throw new errors.ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new openai.OpenAI({
+        apiKey: resolvedApiKey,
+        baseURL: PROVIDER.XAI.BASE_URL,
+    });
+    logger.trace("Initialized xAI client");
+    return client;
+}
+
+class XaiProvider {
+    constructor(model = PROVIDER.XAI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger$2();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: xaiAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: xaiAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages$1(message, options || {});
+        const modelToUse = options?.model || this.model;
+        if (options?.response) {
+            return createStructuredCompletion(client, {
+                messages,
+                responseSchema: options.response,
+                model: modelToUse,
+            });
+        }
+        return createTextCompletion(client, {
+            messages,
+            model: modelToUse,
+        });
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            // If options.history exists, merge with instance history, otherwise use instance history
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
+}
+
 class Llm {
     constructor(providerName = DEFAULT.PROVIDER.NAME, options = {}) {
         const { fallback, model } = options;
         let finalProvider = providerName;
         let finalModel = model;
+        // Legacy: accept "gemini" but warn
+        if (providerName === "gemini") {
+            log$1.warn(`Provider "gemini" is deprecated, use "${PROVIDER.GOOGLE.NAME}" instead`);
+        }
         if (model) {
             const modelDetermined = determineModelProvider(model);
             finalModel = modelDetermined.model;
@@ -5309,6 +7796,10 @@ class Llm {
                 throw new errors.ConfigurationError(`Unable to determine provider from: ${providerName}`);
             }
             finalProvider = providerDetermined.provider;
+            // When providerName is actually a model name, extract the model (#213)
+            if (!finalModel && providerName !== providerDetermined.provider) {
+                finalModel = providerDetermined.model;
+            }
         }
         // Handle conflicts: if both providerName and model specify different providers
         if (model && providerName !== DEFAULT.PROVIDER.NAME) {
@@ -5331,8 +7822,10 @@ class Llm {
         switch (providerName) {
             case PROVIDER.ANTHROPIC.NAME:
                 return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
-            case PROVIDER.GEMINI.NAME:
-                return new GeminiProvider(model || PROVIDER.GEMINI.MODEL.DEFAULT, {
+            case PROVIDER.BEDROCK.NAME:
+                return new BedrockProvider(model || PROVIDER.BEDROCK.MODEL.DEFAULT);
+            case PROVIDER.GOOGLE.NAME:
+                return new GoogleProvider(model || PROVIDER.GOOGLE.MODEL.DEFAULT, {
                     apiKey,
                 });
             case PROVIDER.OPENAI.NAME:
@@ -5343,6 +7836,10 @@ class Llm {
                 return new OpenRouterProvider(model || PROVIDER.OPENROUTER.MODEL.DEFAULT, {
                     apiKey,
                 });
+            case PROVIDER.XAI.NAME:
+                return new XaiProvider(model || PROVIDER.XAI.MODEL.DEFAULT, {
+                    apiKey,
+                });
             default:
                 throw new errors.ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -5397,7 +7894,7 @@ class Llm {
         }
         catch (error) {
             lastError = error;
-            log$2.warn(`Provider ${this._provider} failed`, {
+            log$1.warn(`Provider ${this._provider} failed`, {
                 error: lastError.message,
                 fallbacksRemaining: fallbackChain.length,
             });
@@ -5417,7 +7914,7 @@ class Llm {
             }
             catch (error) {
                 lastError = error;
-                log$2.warn(`Fallback provider ${fallbackConfig.provider} failed`, {
+                log$1.warn(`Fallback provider ${fallbackConfig.provider} failed`, {
                     error: lastError.message,
                     fallbacksRemaining: fallbackChain.length - attempts + 1,
                 });
@@ -5586,16 +8083,17 @@ const roll = {
     },
     type: "function",
     call: ({ number = 1, sides = 6 } = {}) => {
+        const log = getLogger$6();
         const rng = random$1();
         const rolls = [];
         let total = 0;
         const parsedNumber = tryParseNumber(number, {
             defaultValue: 1,
-            warnFunction: log$1.warn,
+            warnFunction: log.warn,
         });
         const parsedSides = tryParseNumber(sides, {
             defaultValue: 6,
-            warnFunction: log$1.warn,
+            warnFunction: log.warn,
         });
         for (let i = 0; i < parsedNumber; i++) {
             const rollValue = rng({ min: 1, max: parsedSides, integer: true });
@@ -5748,8 +8246,10 @@ const weather = {
         }
         catch (error) {
             if (error instanceof Error) {
+                // eslint-disable-next-line preserve-caught-error -- package targets ES2020; Error `cause` option requires ES2022
                 throw new Error(`Weather API error: ${error.message}`);
             }
+            // eslint-disable-next-line preserve-caught-error -- package targets ES2020; Error `cause` option requires ES2022
             throw new Error("Unknown error occurred while fetching weather data");
         }
     },
@@ -5781,12 +8281,15 @@ const toolkit = new JaypieToolkit(tools);
     [exports.LlmMessageRole.Developer]: "user",
 });
 
-exports.GeminiProvider = GeminiProvider;
+exports.BedrockProvider = BedrockProvider;
+exports.GeminiProvider = GoogleProvider;
+exports.GoogleProvider = GoogleProvider;
 exports.JaypieToolkit = JaypieToolkit;
 exports.LLM = constants;
 exports.Llm = Llm;
 exports.OpenRouterProvider = OpenRouterProvider;
 exports.Toolkit = Toolkit;
+exports.XaiProvider = XaiProvider;
 exports.extractReasoning = extractReasoning;
 exports.isLlmOperateInput = isLlmOperateInput;
 exports.isLlmOperateInputContent = isLlmOperateInputContent;