@jaypie/llm 1.2.35 → 1.2.37

package/dist/cjs/index.cjs

@@ -17,7 +17,7 @@ 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",
     },
@@ -25,8 +25,8 @@ const FIRST_CLASS_PROVIDER = {
     GEMINI: {
         DEFAULT: "gemini-3.1-pro-preview",
         LARGE: "gemini-3.1-pro-preview",
-        SMALL: "gemini-3-flash-preview",
-        TINY: "gemini-3.1-flash-lite-preview",
+        SMALL: "gemini-3.5-flash",
+        TINY: "gemini-3.5-flash",
     },
     // https://developers.openai.com/api/docs/models
     OPENAI: {
@@ -37,13 +37,33 @@ const FIRST_CLASS_PROVIDER = {
     },
     // https://docs.x.ai/developers/models
     XAI: {
-        DEFAULT: "grok-4.20-0309-reasoning",
-        LARGE: "grok-4.20-0309-reasoning",
-        SMALL: "grok-4.20-0309-non-reasoning",
+        DEFAULT: "grok-latest",
+        LARGE: "grok-4.3-latest",
+        SMALL: "grok-4-1-fast-reasoning",
         TINY: "grok-4-1-fast-non-reasoning",
     },
 };
 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: {
@@ -212,7 +232,21 @@ 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,
@@ -296,8 +330,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 {
@@ -596,7 +639,7 @@ function jsonSchemaToOpenApi3(schema) {
     return result;
 }
 
-const getLogger$5 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -983,13 +1026,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([
@@ -1122,7 +1165,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] };
@@ -1203,7 +1246,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;
@@ -1353,7 +1396,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (useFallbackStructuredOutput && request.format) {
             log$1.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
             allTools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                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,
@@ -1451,7 +1494,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;
@@ -1484,7 +1527,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: {
@@ -1512,7 +1555,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (streamRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$2(error)) {
+                isTemperatureDeprecationError$3(error)) {
                 this.rememberModelRejectsTemperature(streamRequest.model);
                 streamRequest = {
                     ...streamRequest,
@@ -1770,7 +1813,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;
@@ -1796,7 +1839,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;
@@ -1817,6 +1860,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 === 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: 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: exports.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
@@ -4856,7 +5501,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 {
@@ -4915,7 +5560,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
@@ -5034,7 +5679,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 });
@@ -5147,7 +5792,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
@@ -5459,7 +6104,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 errors.BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
@@ -5577,7 +6222,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
@@ -5707,7 +6352,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
@@ -5853,28 +6498,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$4 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$5 = () => log$1.log.lib({ lib: kit.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 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;
@@ -5895,7 +6540,7 @@ function formatUserMessage$3(message, { data, placeholders } = {}) {
     };
 }
 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 });
@@ -5979,7 +6624,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;
@@ -5988,7 +6633,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() {
@@ -6063,6 +6708,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() {
@@ -6709,6 +7435,8 @@ class Llm {
         switch (providerName) {
             case PROVIDER.ANTHROPIC.NAME:
                 return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
+            case PROVIDER.BEDROCK.NAME:
+                return new BedrockProvider(model || PROVIDER.BEDROCK.MODEL.DEFAULT);
             case PROVIDER.GEMINI.NAME:
                 return new GeminiProvider(model || PROVIDER.GEMINI.MODEL.DEFAULT, {
                     apiKey,
@@ -6968,7 +7696,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;
@@ -7166,6 +7894,7 @@ const toolkit = new JaypieToolkit(tools);
     [exports.LlmMessageRole.Developer]: "user",
 });
 
+exports.BedrockProvider = BedrockProvider;
 exports.GeminiProvider = GeminiProvider;
 exports.JaypieToolkit = JaypieToolkit;
 exports.LLM = constants;