@node-llm/core 1.6.2 → 1.8.0

package/dist/providers/bedrock/Streaming.js

@@ -0,0 +1,240 @@
+/**
+ * Bedrock Streaming Handler
+ *
+ * Handles streaming responses from Bedrock ConverseStream API.
+ * Parses the AWS EventStream binary format to extract JSON chunks.
+ */
+import { validateBedrockConfig, getBedrockEndpoint } from "./config.js";
+import { signRequest } from "../../utils/AwsSigV4.js";
+import { fetchWithTimeout } from "../../utils/fetch.js";
+import { logger } from "../../utils/logger.js";
+import { buildConverseRequest } from "./mapper.js";
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+export class BedrockStreaming {
+    config;
+    authMode;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.authMode = validateBedrockConfig(config);
+        this.baseUrl = getBedrockEndpoint(config.region);
+    }
+    async *execute(request, controller) {
+        const internalController = new AbortController();
+        const abortController = controller || internalController;
+        const signal = request.signal ? request.signal : abortController.signal;
+        const currentToolCalls = new Map();
+        let currentReasoning = "";
+        const modelId = request.model;
+        const url = `${this.baseUrl}/model/${modelId}/converse-stream`;
+        const guardrail = this.config.guardrailIdentifier && this.config.guardrailVersion
+            ? {
+                guardrailIdentifier: this.config.guardrailIdentifier,
+                guardrailVersion: this.config.guardrailVersion
+            }
+            : undefined;
+        const body = buildConverseRequest(request.messages, request.tools, {
+            maxTokens: request.max_tokens,
+            temperature: request.temperature,
+            thinking: request.thinking,
+            guardrail,
+            additionalModelRequestFields: request.additionalModelRequestFields
+        });
+        const bodyJson = JSON.stringify(body);
+        const headers = this.buildHeaders(url, bodyJson, request.headers);
+        logger.logRequest("Bedrock", "POST", url, body);
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers,
+            body: bodyJson,
+            signal
+        }, request.requestTimeout ?? this.config.requestTimeout);
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.logResponse("Bedrock", response.status, response.statusText, errorText);
+            throw new Error(`Bedrock Streaming Error (${response.status}): ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error("No response body from Bedrock streaming");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = new Uint8Array(0);
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                // Append new data to buffer
+                const newBuffer = new Uint8Array(buffer.length + value.length);
+                newBuffer.set(buffer);
+                newBuffer.set(value, buffer.length);
+                buffer = newBuffer;
+                // Parse messages from buffer
+                while (buffer.length >= 12) {
+                    const totalLength = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(0);
+                    if (totalLength < 16 || totalLength > 1024 * 1024) {
+                        // Safety check: skip if total length is unreasonable
+                        logger.error(`Bedrock stream: invalid total length ${totalLength}`);
+                        buffer = buffer.slice(4);
+                        continue;
+                    }
+                    if (buffer.length < totalLength) {
+                        break; // Wait for more data
+                    }
+                    const headersLength = new DataView(buffer.buffer, buffer.byteOffset + 4, 4).getUint32(0);
+                    if (headersLength + 16 > totalLength) {
+                        logger.error(`Bedrock stream: invalid headers length ${headersLength} for total length ${totalLength}`);
+                        buffer = buffer.slice(totalLength);
+                        continue;
+                    }
+                    const payloadLength = totalLength - headersLength - 16;
+                    const payloadOffset = 12 + headersLength;
+                    const payload = buffer.slice(payloadOffset, payloadOffset + payloadLength);
+                    const chunkJson = decoder.decode(payload);
+                    try {
+                        const event = JSON.parse(chunkJson);
+                        const chatChunk = this.parseEvent(event, currentToolCalls, (text) => {
+                            currentReasoning += text;
+                        }, modelId);
+                        if (chatChunk) {
+                            yield chatChunk;
+                        }
+                    }
+                    catch (e) {
+                        // Might be a binary event or malformed JSON (though Bedrock uses JSON in payload)
+                        logger.debug("Failed to parse Bedrock event payload", { chunkJson, error: e });
+                    }
+                    // Advance buffer
+                    buffer = buffer.slice(totalLength);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Parse a Bedrock ConverseStream event into a NodeLLM ChatChunk.
+     */
+    parseEvent(event, toolCalls, onReasoning, modelId) {
+        // Bedrock ConverseStream events can be wrapped or unwrapped depending on model/service version
+        const contentBlockStart = event.contentBlockStart;
+        const contentBlockDelta = event.contentBlockDelta || (event.delta ? event : null);
+        const contentBlockStop = event.contentBlockStop;
+        const messageStop = event.messageStop || (event.stopReason ? event : null);
+        const metadata = event.metadata || (event.usage ? event : null);
+        // 1. Content Block Start (Initialize tools or reasoning)
+        if (contentBlockStart) {
+            const { contentBlockIndex, start } = contentBlockStart;
+            if (start?.toolUse) {
+                toolCalls.set(contentBlockIndex, {
+                    id: start.toolUse.toolUseId,
+                    name: start.toolUse.name,
+                    input: ""
+                });
+            }
+            if (start?.reasoningContent) {
+                return { content: "", thinking: { text: "" }, reasoning: "" };
+            }
+        }
+        // 2. Content Block Delta (Accumulate text, tools, or reasoning)
+        if (contentBlockDelta) {
+            const delta = contentBlockDelta.delta || contentBlockDelta;
+            const contentBlockIndex = contentBlockDelta.contentBlockIndex ?? 0;
+            if (delta.text) {
+                return { content: delta.text };
+            }
+            if (delta.reasoningContent?.text) {
+                onReasoning(delta.reasoningContent.text);
+                return {
+                    content: "",
+                    thinking: { text: delta.reasoningContent.text },
+                    reasoning: delta.reasoningContent.text
+                };
+            }
+            if (delta.toolUse) {
+                const toolCall = toolCalls.get(contentBlockIndex);
+                if (toolCall) {
+                    toolCall.input += delta.toolUse.input;
+                    return null;
+                }
+            }
+        }
+        // 3. Content Block Stop (Finalize tool calls)
+        if (contentBlockStop) {
+            const { contentBlockIndex } = contentBlockStop;
+            const toolCall = toolCalls.get(contentBlockIndex);
+            if (toolCall) {
+                toolCalls.delete(contentBlockIndex);
+                return {
+                    content: "",
+                    tool_calls: [
+                        {
+                            id: toolCall.id,
+                            type: "function",
+                            function: {
+                                name: toolCall.name,
+                                arguments: toolCall.input
+                            }
+                        }
+                    ]
+                };
+            }
+        }
+        // 4. Message Stop
+        if (event.messageStop) {
+            return {
+                content: "",
+                done: true,
+                finish_reason: event.messageStop.stopReason
+            };
+        }
+        // 5. Metadata (Usage)
+        if (event.metadata && event.metadata.usage) {
+            const rawUsage = {
+                input_tokens: event.metadata.usage.inputTokens,
+                output_tokens: event.metadata.usage.outputTokens,
+                total_tokens: event.metadata.usage.totalTokens,
+                cached_tokens: event.metadata.usage.cacheReadInputTokens,
+                cache_creation_tokens: event.metadata.usage.cacheWriteInputTokens
+            };
+            const usage = ModelRegistry.calculateCost(rawUsage, modelId, "bedrock");
+            const metadata = event.metadata.trace ? { trace: event.metadata.trace } : undefined;
+            return { content: "", usage, done: true, metadata };
+        }
+        return null;
+    }
+    buildHeaders(url, body, additionalHeaders) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...additionalHeaders
+        };
+        if (this.authMode === "apiKey") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        else {
+            const signedHeaders = signRequest({
+                method: "POST",
+                url,
+                body,
+                credentials: {
+                    accessKeyId: this.config.accessKeyId,
+                    secretAccessKey: this.config.secretAccessKey,
+                    sessionToken: this.config.sessionToken
+                },
+                region: this.config.region,
+                service: "bedrock"
+            });
+            headers["host"] = signedHeaders.host;
+            headers["x-amz-date"] = signedHeaders["x-amz-date"];
+            headers["x-amz-content-sha256"] = signedHeaders["x-amz-content-sha256"];
+            headers["Authorization"] = signedHeaders.authorization;
+            if (signedHeaders["x-amz-security-token"]) {
+                headers["x-amz-security-token"] = signedHeaders["x-amz-security-token"];
+            }
+        }
+        return headers;
+    }
+}

package/dist/providers/bedrock/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * AWS Bedrock Provider Configuration
+ *
+ * Supports two authentication modes:
+ * 1. API Key (Bearer token) - Simplest, for long-term API keys
+ * 2. SigV4 (IAM credentials) - For EC2/ECS/Lambda with IAM roles
+ */
+export interface BedrockConfig {
+    /**
+     * AWS Region where Bedrock is enabled.
+     * Example: "us-east-1", "us-west-2"
+     */
+    region: string;
+    /**
+     * Long-term API key generated from AWS Bedrock console.
+     * When provided, uses simple Bearer token authentication.
+     * Mutually exclusive with accessKeyId/secretAccessKey.
+     */
+    apiKey?: string;
+    /**
+     * AWS Access Key ID.
+     * Required when using SigV4 authentication (no apiKey).
+     */
+    accessKeyId?: string;
+    /**
+     * AWS Secret Access Key.
+     * Required when using SigV4 authentication (no apiKey).
+     */
+    secretAccessKey?: string;
+    /**
+     * AWS Session Token (optional).
+     * Required for temporary credentials from STS, SSO, or assumed roles.
+     */
+    sessionToken?: string;
+    /**
+     * Request timeout in milliseconds.
+     * Default: 120000 (2 minutes)
+     */
+    requestTimeout?: number;
+    /**
+     * Default Bedrock Guardrail identifier (ID or ARN).
+     */
+    guardrailIdentifier?: string;
+    /**
+     * Default Bedrock Guardrail version (e.g., "1", "DRAFT").
+     */
+    guardrailVersion?: string;
+}
+/**
+ * Validates the configuration and determines the auth mode.
+ */
+export declare function validateBedrockConfig(config: BedrockConfig): "apiKey" | "sigv4";
+/**
+ * Build the Bedrock Runtime endpoint URL for a given region.
+ */
+export declare function getBedrockEndpoint(region: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/providers/bedrock/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAKf;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAKhB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAKtB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAuB/E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/providers/bedrock/config.js

@@ -0,0 +1,33 @@
+/**
+ * AWS Bedrock Provider Configuration
+ *
+ * Supports two authentication modes:
+ * 1. API Key (Bearer token) - Simplest, for long-term API keys
+ * 2. SigV4 (IAM credentials) - For EC2/ECS/Lambda with IAM roles
+ */
+/**
+ * Validates the configuration and determines the auth mode.
+ */
+export function validateBedrockConfig(config) {
+    if (!config.region) {
+        throw new Error("BedrockConfig: region is required");
+    }
+    const hasApiKey = !!config.apiKey;
+    const hasSigV4 = !!(config.accessKeyId && config.secretAccessKey);
+    if (hasApiKey && hasSigV4) {
+        throw new Error("BedrockConfig: provide either apiKey OR accessKeyId/secretAccessKey, not both");
+    }
+    if (hasApiKey) {
+        return "apiKey";
+    }
+    if (hasSigV4) {
+        return "sigv4";
+    }
+    throw new Error("BedrockConfig: provide either apiKey OR accessKeyId/secretAccessKey");
+}
+/**
+ * Build the Bedrock Runtime endpoint URL for a given region.
+ */
+export function getBedrockEndpoint(region) {
+    return `https://bedrock-runtime.${region}.amazonaws.com`;
+}

package/dist/providers/bedrock/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bedrock Provider - Public Exports
+ */
+export declare function registerBedrockProvider(): void;
+export { BedrockProvider, BedrockConfig } from "./BedrockProvider.js";
+export { BedrockChat } from "./Chat.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/bedrock/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,wBAAgB,uBAAuB,SAuBtC;AAED,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,cAAc,YAAY,CAAC"}

package/dist/providers/bedrock/index.js

@@ -0,0 +1,30 @@
+/**
+ * Bedrock Provider - Public Exports
+ */
+import { config as globalConfig } from "../../config.js";
+import { providerRegistry } from "../registry.js";
+import { BedrockProvider } from "./BedrockProvider.js";
+export function registerBedrockProvider() {
+    providerRegistry.register("bedrock", (config) => {
+        const cfg = config || globalConfig;
+        const region = cfg.bedrockRegion;
+        if (!region) {
+            throw new Error("bedrockRegion is not set in config or AWS_REGION environment variable");
+        }
+        // Pass all available credentials to the provider.
+        // BedrockProvider.validateBedrockConfig will ensure they are mutually exclusive.
+        const bedrockConfig = {
+            region,
+            apiKey: cfg.bedrockApiKey,
+            accessKeyId: cfg.bedrockAccessKeyId,
+            secretAccessKey: cfg.bedrockSecretAccessKey,
+            sessionToken: cfg.bedrockSessionToken,
+            guardrailIdentifier: cfg.bedrockGuardrailIdentifier,
+            guardrailVersion: cfg.bedrockGuardrailVersion
+        };
+        return new BedrockProvider(bedrockConfig);
+    });
+}
+export { BedrockProvider } from "./BedrockProvider.js";
+export { BedrockChat } from "./Chat.js";
+export * from "./types.js";

package/dist/providers/bedrock/mapper.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bedrock Message Mapper
+ *
+ * Converts NodeLLM messages to Bedrock Converse API format.
+ * Handles system messages, tool calls, and content blocks.
+ */
+import { Message } from "../../chat/Message.js";
+import { ToolDefinition } from "../../chat/Tool.js";
+import { BedrockMessage, BedrockContentBlock, BedrockConverseRequest, BedrockToolConfig } from "./types.js";
+import { ThinkingConfig } from "../../providers/Provider.js";
+/**
+ * Convert NodeLLM messages to Bedrock Converse format.
+ * Extracts system messages to the top-level system field.
+ */
+export declare function convertMessages(messages: Message[]): {
+    messages: BedrockMessage[];
+    system?: BedrockContentBlock[];
+};
+/**
+ * Convert NodeLLM tool definitions to Bedrock tool config.
+ */
+export declare function convertTools(tools?: ToolDefinition[]): BedrockToolConfig | undefined;
+/**
+ * Build a complete Bedrock Converse request from NodeLLM ChatRequest.
+ */
+export declare function buildConverseRequest(messages: Message[], tools?: ToolDefinition[], options?: {
+    maxTokens?: number;
+    temperature?: number;
+    thinking?: ThinkingConfig;
+    guardrail?: {
+        guardrailIdentifier: string;
+        guardrailVersion: string;
+        trace?: "enabled" | "disabled";
+    };
+    additionalModelRequestFields?: Record<string, any>;
+}): BedrockConverseRequest;
+//# sourceMappingURL=mapper.d.ts.map

package/dist/providers/bedrock/mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../../../src/providers/bedrock/mapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAiD7D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG;IACpD,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAChC,CAuFA;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,cAAc,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAgBpF;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,CAAC,EAAE,cAAc,EAAE,EACxB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE;QACV,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,MAAM,CAAC;QACzB,KAAK,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;KAChC,CAAC;IACF,4BAA4B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACpD,GACA,sBAAsB,CAmDxB"}

package/dist/providers/bedrock/mapper.js

@@ -0,0 +1,204 @@
+/**
+ * Bedrock Message Mapper
+ *
+ * Converts NodeLLM messages to Bedrock Converse API format.
+ * Handles system messages, tool calls, and content blocks.
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Message Conversion
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Convert a NodeLLM message to Bedrock content blocks.
+ */
+function messageContentToBlocks(content) {
+    if (typeof content === "string") {
+        return content ? [{ text: content }] : [];
+    }
+    if (Array.isArray(content)) {
+        const blocks = [];
+        for (const part of content) {
+            if (part.type === "text") {
+                const block = { text: part.text };
+                blocks.push(block);
+                if (part.cache_control?.type === "ephemeral") {
+                    blocks.push({ cachePoint: { type: "default" } });
+                }
+            }
+            else if (part.type === "image_url" && part.image_url) {
+                // Extract base64 data from data URL
+                const match = part.image_url.url.match(/^data:image\/(\w+);base64,(.+)$/);
+                if (match && match[1] && match[2]) {
+                    blocks.push({
+                        image: {
+                            format: match[1].replace("jpg", "jpeg"),
+                            source: { bytes: match[2] }
+                        }
+                    });
+                }
+                else {
+                    // Fallback if not a data URL or missing base64
+                    blocks.push({ text: `[Image: ${part.image_url.url}]` });
+                }
+            }
+            else {
+                // Default to empty text for unsupported types
+                blocks.push({ text: "" });
+            }
+        }
+        return blocks.filter((b) => b.text !== "");
+    }
+    return [];
+}
+/**
+ * Convert NodeLLM messages to Bedrock Converse format.
+ * Extracts system messages to the top-level system field.
+ */
+export function convertMessages(messages) {
+    const systemBlocks = [];
+    const bedrockMessages = [];
+    let currentToolResults = [];
+    const flushToolResults = () => {
+        if (currentToolResults.length > 0) {
+            bedrockMessages.push({
+                role: "user",
+                content: currentToolResults
+            });
+            currentToolResults = [];
+        }
+    };
+    for (const msg of messages) {
+        if (msg.role !== "tool") {
+            flushToolResults();
+        }
+        // System messages go to the top-level system field
+        if (msg.role === "system") {
+            const blocks = messageContentToBlocks(msg.content);
+            systemBlocks.push(...blocks);
+            continue;
+        }
+        // User messages
+        if (msg.role === "user") {
+            bedrockMessages.push({
+                role: "user",
+                content: messageContentToBlocks(msg.content)
+            });
+            continue;
+        }
+        // Assistant messages (may include tool calls and reasoning)
+        if (msg.role === "assistant") {
+            const contentBlocks = messageContentToBlocks(msg.content);
+            // Add reasoning content if present
+            if (msg.reasoning) {
+                contentBlocks.unshift({
+                    reasoningContent: {
+                        text: msg.reasoning
+                    }
+                });
+            }
+            // Add tool use blocks if present
+            if (msg.tool_calls) {
+                for (const toolCall of msg.tool_calls) {
+                    contentBlocks.push({
+                        toolUse: {
+                            toolUseId: toolCall.id,
+                            name: toolCall.function.name,
+                            input: JSON.parse(toolCall.function.arguments || "{}")
+                        }
+                    });
+                }
+            }
+            bedrockMessages.push({
+                role: "assistant",
+                content: contentBlocks
+            });
+            continue;
+        }
+        // Tool result messages
+        if (msg.role === "tool") {
+            currentToolResults.push({
+                toolResult: {
+                    toolUseId: msg.tool_call_id || "",
+                    content: [{ text: typeof msg.content === "string" ? msg.content : "" }],
+                    status: msg.isError ? "error" : "success"
+                }
+            });
+        }
+    }
+    flushToolResults();
+    return {
+        messages: bedrockMessages,
+        system: systemBlocks.length > 0 ? systemBlocks : undefined
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Tool Conversion
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Convert NodeLLM tool definitions to Bedrock tool config.
+ */
+export function convertTools(tools) {
+    if (!tools || tools.length === 0) {
+        return undefined;
+    }
+    return {
+        tools: tools.map((tool) => ({
+            toolSpec: {
+                name: tool.function.name,
+                description: tool.function.description,
+                inputSchema: {
+                    json: tool.function.parameters || {}
+                }
+            }
+        }))
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Request Builder
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Build a complete Bedrock Converse request from NodeLLM ChatRequest.
+ */
+export function buildConverseRequest(messages, tools, options) {
+    const { messages: bedrockMessages, system } = convertMessages(messages);
+    const request = {
+        messages: bedrockMessages
+    };
+    if (system) {
+        request.system = system;
+    }
+    const toolConfig = convertTools(tools);
+    if (toolConfig) {
+        request.toolConfig = toolConfig;
+    }
+    if (options?.guardrail) {
+        request.guardrailConfig = options.guardrail;
+    }
+    // Inference config (only add if we have values)
+    if (options?.maxTokens || options?.temperature !== undefined) {
+        request.inferenceConfig = {};
+        if (options.maxTokens) {
+            request.inferenceConfig.maxTokens = options.maxTokens;
+        }
+        if (options.temperature !== undefined) {
+            request.inferenceConfig.temperature = options.temperature;
+        }
+    }
+    // Thinking config for Claude 3.7+
+    if (options?.thinking?.budget) {
+        request.additionalModelRequestFields = {
+            ...request.additionalModelRequestFields,
+            thinking: {
+                type: "enabled",
+                budget_tokens: options.thinking.budget
+            }
+        };
+    }
+    // Merge any other additional fields
+    if (options?.additionalModelRequestFields) {
+        request.additionalModelRequestFields = {
+            ...request.additionalModelRequestFields,
+            ...options.additionalModelRequestFields
+        };
+    }
+    return request;
+}