@jaypie/llm 1.2.36 → 1.2.38

package/dist/esm/index.js

@@ -15,16 +15,16 @@ const FIRST_CLASS_PROVIDER = {
     // https://docs.anthropic.com/en/docs/about-claude/models/overview
     ANTHROPIC: {
         DEFAULT: "claude-sonnet-4-6",
-        LARGE: "claude-opus-4-7",
+        LARGE: "claude-opus-4-8",
         SMALL: "claude-sonnet-4-6",
         TINY: "claude-haiku-4-5",
     },
     // https://ai.google.dev/gemini-api/docs/models
-    GEMINI: {
+    GOOGLE: {
         DEFAULT: "gemini-3.1-pro-preview",
         LARGE: "gemini-3.1-pro-preview",
-        SMALL: "gemini-3.1-flash-lite-preview",
-        TINY: "gemini-3.1-flash-lite-preview",
+        SMALL: "gemini-3.5-flash",
+        TINY: "gemini-3.1-flash-lite",
     },
     // https://developers.openai.com/api/docs/models
     OPENAI: {
@@ -41,7 +41,60 @@ const FIRST_CLASS_PROVIDER = {
         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.5-mini",
+    GPT_NANO: "gpt-5.5-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: {
@@ -74,21 +127,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: "google",
-        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: {
@@ -144,7 +185,7 @@ 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,
     ],
@@ -154,10 +195,10 @@ const ALL = {
             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.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,
@@ -170,19 +211,19 @@ const ALL = {
     ],
     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,
     ],
@@ -192,6 +233,7 @@ var constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ALL: ALL,
     DEFAULT: DEFAULT,
+    MODEL: MODEL,
     PROVIDER: PROVIDER
 });
 
@@ -210,17 +252,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 || input === "gemini") {
+    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) {
@@ -251,11 +307,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,
             };
         }
     }
@@ -294,8 +350,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 {
@@ -305,11 +370,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,
             };
         }
     }
@@ -594,7 +659,7 @@ function jsonSchemaToOpenApi3(schema) {
     return result;
 }
 
-const getLogger$5 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$6 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -981,13 +1046,13 @@ function isTransientNetworkError(error) {
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+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 = /^data:([^;]+);base64,(.+)$/;
+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([
@@ -1120,7 +1185,7 @@ function isJsonSchema(value) {
  * Parse a data URL into its components
  */
 function parseDataUrl(dataUrl) {
-    const match = dataUrl.match(DATA_URL_REGEX);
+    const match = dataUrl.match(DATA_URL_REGEX$1);
     if (!match)
         return null;
     return { mediaType: match[1], data: match[2] };
@@ -1201,7 +1266,7 @@ const MODELS_WITHOUT_TEMPERATURE$2 = [
     /^claude-opus-4-[789]/,
     /^claude-opus-[5-9]/,
 ];
-function isTemperatureDeprecationError$2(error) {
+function isTemperatureDeprecationError$3(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
@@ -1351,7 +1416,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (useFallbackStructuredOutput && request.format) {
             log$2.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
             allTools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                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,
@@ -1449,7 +1514,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 return undefined;
             // If the model rejected `temperature`, cache it and retry without the param
             if (anthropicRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$2(error)) {
+                isTemperatureDeprecationError$3(error)) {
                 this.rememberModelRejectsTemperature(anthropicRequest.model);
                 const retryRequest = { ...anthropicRequest };
                 delete retryRequest.temperature;
@@ -1482,7 +1547,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             return request;
         const fallbackRequest = { ...rest };
         const fakeTool = {
-            name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+            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: {
@@ -1510,7 +1575,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (streamRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$2(error)) {
+                isTemperatureDeprecationError$3(error)) {
                 this.rememberModelRejectsTemperature(streamRequest.model);
                 streamRequest = {
                     ...streamRequest,
@@ -1768,7 +1833,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // runtime has cached as not supporting `output_format`.
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         return (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$3);
     }
     extractStructuredOutput(response) {
         const anthropicResponse = response;
@@ -1794,7 +1859,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Fallback path: legacy fake-tool emulation
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         if (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$3) {
             return lastBlock.input;
         }
         return undefined;
@@ -1815,6 +1880,608 @@ class AnthropicAdapter extends BaseProviderAdapter {
 // 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 === LlmMessageType.InputText) {
+            return { text: item.text };
+        }
+        if (item.type === 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 === 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 === 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 === 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 z.ZodType
+            ? schema
+            : naturalZodSchema(schema);
+        return 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: LlmStreamChunkType.Text, content: delta.text };
+                }
+                else if (delta.toolUse?.input && currentToolCall) {
+                    currentToolCall.arguments += delta.toolUse.input;
+                }
+            }
+            else if (event.contentBlockStop && currentToolCall) {
+                yield {
+                    type: 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: 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: bedrockResponse.stopReason ?? undefined,
+            usage: this.extractUsage(bedrockResponse, bedrockResponse.modelId ||
+                this.defaultModel),
+            raw: bedrockResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const bedrockResponse = response;
+        const content = bedrockResponse.output?.message?.content ?? [];
+        const toolCalls = [];
+        for (const block of content) {
+            const typedBlock = block;
+            if ("toolUse" in typedBlock && typedBlock.toolUse) {
+                const toolUse = typedBlock.toolUse;
+                toolCalls.push({
+                    callId: toolUse.toolUseId,
+                    name: toolUse.name,
+                    arguments: JSON.stringify(toolUse.input),
+                    raw: typedBlock,
+                });
+            }
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const bedrockResponse = response;
+        const usage = bedrockResponse.usage;
+        return {
+            input: usage?.inputTokens ?? 0,
+            output: usage?.outputTokens ?? 0,
+            reasoning: 0,
+            total: usage?.totalTokens ??
+                (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0),
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            toolResult: {
+                toolUseId: toolCall.callId,
+                content: [{ text: result.output }],
+            },
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const bedrockRequest = request;
+        const toolCallRaw = toolCall.raw;
+        bedrockRequest.messages.push({
+            role: "assistant",
+            content: [toolCallRaw],
+        });
+        bedrockRequest.messages.push({
+            role: "user",
+            content: [this.formatToolResult(toolCall, result)],
+        });
+        return bedrockRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const bedrockResponse = response;
+        const historyItems = [];
+        if (bedrockResponse.stopReason === "tool_use") {
+            return historyItems;
+        }
+        const content = bedrockResponse.output?.message?.content ?? [];
+        const textBlock = content.find((block) => "text" in block);
+        if (textBlock) {
+            historyItems.push({
+                content: textBlock.text,
+                role: "assistant",
+                type: LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        const errorName = error?.constructor?.name;
+        const errorMessage = error?.message ?? "";
+        if (errorName === "ThrottlingException" ||
+            errorMessage.includes("ThrottlingException") ||
+            errorMessage.includes("Too Many Requests")) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        if (errorName === "ServiceUnavailableException" ||
+            errorName === "InternalServerException" ||
+            errorMessage.includes("ServiceUnavailableException") ||
+            errorMessage.includes("InternalServerException")) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        if (errorName === "AccessDeniedException" ||
+            errorName === "ValidationException" ||
+            errorName === "ResourceNotFoundException" ||
+            errorMessage.includes("AccessDeniedException") ||
+            errorMessage.includes("ValidationException")) {
+            return {
+                error,
+                category: ErrorCategory.Unrecoverable,
+                shouldRetry: false,
+            };
+        }
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Structured Output
+    //
+    hasStructuredOutput(response) {
+        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 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
+    //
+    extractContentFromMessage(message) {
+        if (!message?.content)
+            return undefined;
+        const content = message.content;
+        const textBlock = content.find((block) => "text" in block);
+        return textBlock?.text;
+    }
+}
+const bedrockAdapter = new BedrockAdapter();
+
 //
 //
 // Constants
@@ -1863,15 +2530,15 @@ 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.
@@ -1926,7 +2593,7 @@ class GeminiAdapter extends BaseProviderAdapter {
             ? [...request.tools]
             : [];
         if (request.format && hasUserTools && !useNativeCombo) {
-            log$2.warn(`[GeminiAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+            log$2.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, " +
@@ -2057,7 +2724,7 @@ class GeminiAdapter extends BaseProviderAdapter {
             if (wantsNativeCombo && isStructuredOutputComboUnsupportedError(error)) {
                 const model = geminiRequest.model;
                 this.rememberModelRejectsStructuredOutputCombo(model);
-                log$2.warn(`[GeminiAdapter] Model ${model} rejected native responseJsonSchema + tools combo; falling back to legacy structured_output tool emulation.`);
+                log$2.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,
@@ -2639,7 +3306,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 = [
@@ -4854,7 +5521,7 @@ function matchesCaughtError(reason, caught) {
  * (e.g. undici `TypeError: terminated`) emitted between attempts.
  */
 function createStaleRejectionGuard() {
-    const log = getLogger$5();
+    const log = getLogger$6();
     const caughtErrors = new Set();
     let listener;
     return {
@@ -4913,7 +5580,7 @@ class RetryExecutor {
      * @throws BadGatewayError if all retries are exhausted or error is not retryable
      */
     async execute(operation, options) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         let attempt = 0;
         // Guard against stale rejections firing on a subsequent microtask after
         // the retry layer has already caught the originating error: undici socket
@@ -5032,7 +5699,7 @@ class OperateLoop {
      * Execute the operate loop for multi-turn conversations with tool calling.
      */
     async execute(input, options = {}) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         // Log what was passed to operate
         log.trace("[operate] Starting operate loop");
         log.var({ "operate.input": input });
@@ -5145,7 +5812,7 @@ class OperateLoop {
         };
     }
     async executeOneTurn(request, state, context, options) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         // Create error classifier from adapter
         const errorClassifier = createErrorClassifier(this.adapter);
         // Create retry executor for this turn
@@ -5457,7 +6124,7 @@ class StreamLoop {
      * Yields stream chunks as they become available.
      */
     async *execute(input, options = {}) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         // Verify adapter supports streaming
         if (!this.adapter.executeStreamRequest) {
             throw new BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
@@ -5575,7 +6242,7 @@ class StreamLoop {
         };
     }
     async *executeOneStreamingTurn(request, state, context, options) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
         // Execute beforeEachModelRequest hook
@@ -5705,7 +6372,7 @@ class StreamLoop {
         return { shouldContinue: false };
     }
     async *processToolCalls(toolCalls, state, context, _options) {
-        const log = getLogger$5();
+        const log = getLogger$6();
         for (const toolCall of toolCalls) {
             try {
                 // Execute beforeEachTool hook
@@ -5851,28 +6518,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 ConfigurationError("@anthropic-ai/sdk is required but not installed. Run: npm install @anthropic-ai/sdk");
     }
 }
 // Logger
-const getLogger$4 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$5 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$4({ apiKey, } = {}) {
-    const logger = getLogger$4();
+async function initializeClient$5({ apiKey, } = {}) {
+    const logger = getLogger$5();
     const resolvedApiKey = apiKey || (await getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
         throw new 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;
@@ -5893,7 +6560,7 @@ function formatUserMessage$3(message, { data, placeholders: placeholders$1 } = {
     };
 }
 function prepareMessages$3(message, { data, placeholders } = {}) {
-    const logger = getLogger$4();
+    const logger = getLogger$5();
     const messages = [];
     // Add user message (necessary for all requests)
     const userMessage = formatUserMessage$3(message, { data, placeholders });
@@ -5977,7 +6644,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$4();
+        this.log = getLogger$5();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -5986,7 +6653,7 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$4({ apiKey: this.apiKey });
+        this._client = await initializeClient$5({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -6061,6 +6728,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 ConfigurationError("@aws-sdk/client-bedrock-runtime is required but not installed. Run: npm install @aws-sdk/client-bedrock-runtime");
+    }
+}
+const getLogger$4 = () => log$1.lib({ lib: 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() {
@@ -6109,8 +6857,8 @@ function prepareMessages$2(message, { data, placeholders } = {}) {
     return { messages, systemInstruction: undefined };
 }
 
-class GeminiProvider {
-    constructor(model = PROVIDER.GEMINI.MODEL.DEFAULT, { apiKey } = {}) {
+class GoogleProvider {
+    constructor(model = PROVIDER.GOOGLE.MODEL.DEFAULT, { apiKey } = {}) {
         this.log = getLogger$3();
         this.conversationHistory = [];
         this.model = model;
@@ -6129,7 +6877,7 @@ class GeminiProvider {
         }
         const client = await this.getClient();
         this._operateLoop = createOperateLoop({
-            adapter: geminiAdapter,
+            adapter: googleAdapter,
             client,
         });
         return this._operateLoop;
@@ -6140,7 +6888,7 @@ class GeminiProvider {
         }
         const client = await this.getClient();
         this._streamLoop = createStreamLoop({
-            adapter: geminiAdapter,
+            adapter: googleAdapter,
             client,
         });
         return this._streamLoop;
@@ -6665,7 +7413,7 @@ class Llm {
         let finalModel = model;
         // Legacy: accept "gemini" but warn
         if (providerName === "gemini") {
-            log$2.warn(`Provider "gemini" is deprecated, use "${PROVIDER.GEMINI.NAME}" instead`);
+            log$2.warn(`Provider "gemini" is deprecated, use "${PROVIDER.GOOGLE.NAME}" instead`);
         }
         if (model) {
             const modelDetermined = determineModelProvider(model);
@@ -6707,8 +7455,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:
@@ -6966,7 +7716,7 @@ const roll = {
     },
     type: "function",
     call: ({ number = 1, sides = 6 } = {}) => {
-        const log = getLogger$5();
+        const log = getLogger$6();
         const rng = random$1();
         const rolls = [];
         let total = 0;
@@ -7164,5 +7914,5 @@ const toolkit = new JaypieToolkit(tools);
     [LlmMessageRole.Developer]: "user",
 });
 
-export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
+export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
 //# sourceMappingURL=index.js.map