promptfoo 0.119.13 → 0.119.14

package/dist/src/providers/bedrock/converse.js

@@ -0,0 +1,1044 @@
+"use strict";
+/**
+ * AWS Bedrock Converse API Provider
+ *
+ * This provider implements the AWS Bedrock Converse API, which provides a unified
+ * interface for all Bedrock models. It supports:
+ * - Extended thinking (reasoning/ultrathink) for Claude models
+ * - Tool calling with standardized format
+ * - Streaming responses via ConverseStream
+ * - Performance configuration (latency optimization, service tiers)
+ * - Guardrails integration
+ * - Cache token tracking
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsBedrockConverseProvider = void 0;
+exports.parseConverseMessages = parseConverseMessages;
+const path_1 = __importDefault(require("path"));
+const cache_1 = require("../../cache");
+const cliState_1 = __importDefault(require("../../cliState"));
+const esm_1 = require("../../esm");
+const envars_1 = require("../../envars");
+const logger_1 = __importDefault(require("../../logger"));
+const telemetry_1 = __importDefault(require("../../telemetry"));
+const fileExtensions_1 = require("../../util/fileExtensions");
+const index_1 = require("../../util/index");
+const base_1 = require("./base");
+/**
+ * Bedrock model pricing per 1M tokens
+ * Prices as of 2025 - may need updates
+ */
+const BEDROCK_CONVERSE_PRICING = {
+    // Claude Opus 4.5
+    'anthropic.claude-opus-4-5': { input: 5, output: 25 },
+    // Claude Opus 4/4.1
+    'anthropic.claude-opus-4': { input: 15, output: 75 },
+    // Claude Sonnet 4/4.5
+    'anthropic.claude-sonnet-4': { input: 3, output: 15 },
+    // Claude Haiku 4.5
+    'anthropic.claude-haiku-4': { input: 1, output: 5 },
+    // Claude 3.x
+    'anthropic.claude-3-opus': { input: 15, output: 75 },
+    'anthropic.claude-3-5-sonnet': { input: 3, output: 15 },
+    'anthropic.claude-3-7-sonnet': { input: 3, output: 15 },
+    'anthropic.claude-3-5-haiku': { input: 0.8, output: 4 },
+    'anthropic.claude-3-haiku': { input: 0.25, output: 1.25 },
+    // Amazon Nova
+    'amazon.nova-micro': { input: 0.035, output: 0.14 },
+    'amazon.nova-lite': { input: 0.06, output: 0.24 },
+    'amazon.nova-pro': { input: 0.8, output: 3.2 },
+    'amazon.nova-premier': { input: 2.5, output: 10 },
+    // Amazon Titan Text
+    'amazon.titan-text-lite': { input: 0.15, output: 0.2 },
+    'amazon.titan-text-express': { input: 0.8, output: 1.6 },
+    'amazon.titan-text-premier': { input: 0.5, output: 1.5 },
+    // Meta Llama
+    'meta.llama3-1-8b': { input: 0.22, output: 0.22 },
+    'meta.llama3-1-70b': { input: 0.99, output: 0.99 },
+    'meta.llama3-1-405b': { input: 5.32, output: 16 },
+    'meta.llama3-2-1b': { input: 0.1, output: 0.1 },
+    'meta.llama3-2-3b': { input: 0.15, output: 0.15 },
+    'meta.llama3-2-11b': { input: 0.35, output: 0.35 },
+    'meta.llama3-2-90b': { input: 2.0, output: 2.0 },
+    'meta.llama3-3-70b': { input: 0.99, output: 0.99 },
+    'meta.llama4-scout': { input: 0.17, output: 0.68 },
+    'meta.llama4-maverick': { input: 0.17, output: 0.68 },
+    'meta.llama4': { input: 1.0, output: 3.0 },
+    // Mistral
+    'mistral.mistral-7b': { input: 0.15, output: 0.2 },
+    'mistral.mixtral-8x7b': { input: 0.45, output: 0.7 },
+    'mistral.mistral-large': { input: 4, output: 12 },
+    'mistral.mistral-small': { input: 1, output: 3 },
+    'mistral.pixtral-large': { input: 2, output: 6 },
+    // AI21 Jamba
+    'ai21.jamba-1-5-mini': { input: 0.2, output: 0.4 },
+    'ai21.jamba-1-5-large': { input: 2, output: 8 },
+    // Cohere
+    'cohere.command-r': { input: 0.5, output: 1.5 },
+    'cohere.command-r-plus': { input: 3, output: 15 },
+    // DeepSeek
+    'deepseek.deepseek-r1': { input: 1.35, output: 5.4 },
+    'deepseek.r1': { input: 1.35, output: 5.4 },
+    // Qwen
+    'qwen.qwen3-32b': { input: 0.2, output: 0.6 },
+    'qwen.qwen3-235b': { input: 0.18, output: 0.54 },
+    'qwen.qwen3-coder-30b': { input: 0.2, output: 0.6 },
+    'qwen.qwen3-coder-480b': { input: 1.5, output: 7.5 },
+    'qwen.qwen3': { input: 0.5, output: 1.5 },
+    // Writer Palmyra
+    'writer.palmyra-x5': { input: 0.6, output: 6 },
+    'writer.palmyra-x4': { input: 2.5, output: 10 },
+    // OpenAI GPT-OSS
+    'openai.gpt-oss-120b': { input: 1.0, output: 3.0 },
+    'openai.gpt-oss-20b': { input: 0.3, output: 0.9 },
+};
+/**
+ * Calculate cost based on model and token usage
+ */
+function calculateBedrockConverseCost(modelId, promptTokens, completionTokens) {
+    if (promptTokens === undefined || completionTokens === undefined) {
+        return undefined;
+    }
+    // Find matching pricing
+    const normalizedModelId = modelId.toLowerCase();
+    for (const [modelPrefix, pricing] of Object.entries(BEDROCK_CONVERSE_PRICING)) {
+        if (normalizedModelId.includes(modelPrefix)) {
+            const inputCost = (promptTokens / 1000000) * pricing.input;
+            const outputCost = (completionTokens / 1000000) * pricing.output;
+            return inputCost + outputCost;
+        }
+    }
+    return undefined;
+}
+/**
+ * Convert various tool formats to Converse API format
+ */
+function convertToolsToConverseFormat(tools) {
+    return tools.map((tool) => {
+        // Already in Converse format - cast to expected type
+        if (tool.toolSpec) {
+            return { toolSpec: tool.toolSpec };
+        }
+        // OpenAI-compatible format
+        if (tool.type === 'function' && tool.function) {
+            return {
+                toolSpec: {
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    inputSchema: {
+                        json: (tool.function.parameters || {}),
+                    },
+                },
+            };
+        }
+        // Anthropic format
+        if (tool.name) {
+            return {
+                toolSpec: {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: {
+                        json: (tool.input_schema || {}),
+                    },
+                },
+            };
+        }
+        throw new Error(`Invalid tool configuration: ${JSON.stringify(tool)}`);
+    });
+}
+/**
+ * Convert tool choice to Converse API format
+ */
+function convertToolChoiceToConverseFormat(toolChoice) {
+    if (toolChoice === 'auto') {
+        return { auto: {} };
+    }
+    if (toolChoice === 'any') {
+        return { any: {} };
+    }
+    if (typeof toolChoice === 'object' && toolChoice.tool) {
+        return { tool: { name: toolChoice.tool.name } };
+    }
+    return { auto: {} };
+}
+/**
+ * Parse prompt into Converse API message format
+ */
+function parseConverseMessages(prompt) {
+    // Try to parse as JSON first
+    try {
+        const parsed = JSON.parse(prompt);
+        if (Array.isArray(parsed)) {
+            const systemMessages = [];
+            const messages = [];
+            for (const msg of parsed) {
+                if (msg.role === 'system') {
+                    // System messages go to the system field
+                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                    systemMessages.push({ text: content });
+                }
+                else if (msg.role === 'user' || msg.role === 'assistant') {
+                    // Convert content to ContentBlock format
+                    const contentBlocks = [];
+                    if (typeof msg.content === 'string') {
+                        contentBlocks.push({ text: msg.content });
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        for (const block of msg.content) {
+                            if (typeof block === 'string') {
+                                contentBlocks.push({ text: block });
+                            }
+                            else if (block.type === 'text') {
+                                contentBlocks.push({ text: block.text });
+                            }
+                            else if (block.type === 'image' || block.image) {
+                                // Handle image content - multiple formats supported
+                                const imageData = block.image || block;
+                                let bytes;
+                                let format = 'png';
+                                // Determine format from various sources
+                                if (imageData.format) {
+                                    format = imageData.format;
+                                }
+                                else if (imageData.source?.media_type) {
+                                    format = imageData.source.media_type.split('/')[1] || 'png';
+                                }
+                                // Get bytes from various sources
+                                if (imageData.source?.bytes) {
+                                    const rawBytes = imageData.source.bytes;
+                                    if (typeof rawBytes === 'string') {
+                                        // Check for data URL format: data:image/jpeg;base64,...
+                                        if (rawBytes.startsWith('data:')) {
+                                            const matches = rawBytes.match(/^data:image\/([^;]+);base64,(.+)$/);
+                                            if (matches) {
+                                                format = matches[1] === 'jpg' ? 'jpeg' : matches[1];
+                                                bytes = Buffer.from(matches[2], 'base64');
+                                            }
+                                        }
+                                        else {
+                                            // Assume raw base64 string
+                                            bytes = Buffer.from(rawBytes, 'base64');
+                                        }
+                                    }
+                                    else if (Buffer.isBuffer(rawBytes)) {
+                                        bytes = rawBytes;
+                                    }
+                                }
+                                else if (imageData.source?.data) {
+                                    // Anthropic format: {source: {type: 'base64', media_type: '...', data: '...'}}
+                                    bytes = Buffer.from(imageData.source.data, 'base64');
+                                }
+                                if (bytes) {
+                                    // Normalize format names for Converse API
+                                    if (format === 'jpg') {
+                                        format = 'jpeg';
+                                    }
+                                    contentBlocks.push({
+                                        image: {
+                                            format: format,
+                                            source: { bytes },
+                                        },
+                                    });
+                                }
+                                else {
+                                    logger_1.default.warn('Could not parse image content block', { block });
+                                }
+                            }
+                            else if (block.type === 'image_url' || block.image_url) {
+                                // OpenAI-compatible image_url format
+                                const imageUrl = block.image_url?.url || block.url;
+                                if (typeof imageUrl === 'string' && imageUrl.startsWith('data:')) {
+                                    const matches = imageUrl.match(/^data:image\/([^;]+);base64,(.+)$/);
+                                    if (matches) {
+                                        const format = matches[1] === 'jpg' ? 'jpeg' : matches[1];
+                                        const bytes = Buffer.from(matches[2], 'base64');
+                                        contentBlocks.push({
+                                            image: {
+                                                format: format,
+                                                source: { bytes },
+                                            },
+                                        });
+                                    }
+                                }
+                                else {
+                                    logger_1.default.warn('Unsupported image_url format (only data URLs supported)', {
+                                        imageUrl,
+                                    });
+                                }
+                            }
+                            else if (block.type === 'document' || block.document) {
+                                // Handle document content
+                                const docData = block.document || block;
+                                let bytes;
+                                const format = docData.format || 'txt';
+                                const name = docData.name || 'document';
+                                if (docData.source?.bytes) {
+                                    const rawBytes = docData.source.bytes;
+                                    if (typeof rawBytes === 'string') {
+                                        // Check for data URL format
+                                        if (rawBytes.startsWith('data:')) {
+                                            const matches = rawBytes.match(/^data:[^;]+;base64,(.+)$/);
+                                            if (matches) {
+                                                bytes = Buffer.from(matches[1], 'base64');
+                                            }
+                                        }
+                                        else {
+                                            bytes = Buffer.from(rawBytes, 'base64');
+                                        }
+                                    }
+                                    else if (Buffer.isBuffer(rawBytes)) {
+                                        bytes = rawBytes;
+                                    }
+                                }
+                                if (bytes) {
+                                    contentBlocks.push({
+                                        document: {
+                                            format: format,
+                                            name,
+                                            source: { bytes },
+                                        },
+                                    });
+                                }
+                                else {
+                                    logger_1.default.warn('Could not parse document content block', { block });
+                                }
+                            }
+                            else if (block.type === 'tool_use' || block.toolUse) {
+                                const toolUseData = block.toolUse || block;
+                                contentBlocks.push({
+                                    toolUse: {
+                                        toolUseId: toolUseData.toolUseId || toolUseData.id,
+                                        name: toolUseData.name,
+                                        input: toolUseData.input,
+                                    },
+                                });
+                            }
+                            else if (block.type === 'tool_result' || block.toolResult) {
+                                const toolResultData = block.toolResult || block;
+                                contentBlocks.push({
+                                    toolResult: {
+                                        toolUseId: toolResultData.toolUseId || toolResultData.tool_use_id,
+                                        content: Array.isArray(toolResultData.content)
+                                            ? toolResultData.content.map((c) => typeof c === 'string' ? { text: c } : c)
+                                            : [{ text: String(toolResultData.content) }],
+                                        status: toolResultData.status,
+                                    },
+                                });
+                            }
+                            else {
+                                // Unknown block type, try to convert to text
+                                contentBlocks.push({ text: JSON.stringify(block) });
+                            }
+                        }
+                    }
+                    else {
+                        contentBlocks.push({ text: JSON.stringify(msg.content) });
+                    }
+                    messages.push({
+                        role: msg.role,
+                        content: contentBlocks,
+                    });
+                }
+            }
+            return {
+                messages,
+                system: systemMessages.length > 0 ? systemMessages : undefined,
+            };
+        }
+    }
+    catch {
+        // Not JSON, try line-based parsing
+    }
+    // Parse as line-based format or plain text
+    const lines = prompt.split('\n');
+    const messages = [];
+    let system;
+    let currentRole = null;
+    let currentContent = [];
+    const pushMessage = () => {
+        if (currentRole && currentContent.length > 0) {
+            messages.push({
+                role: currentRole,
+                content: [{ text: currentContent.join('\n') }],
+            });
+            currentContent = [];
+        }
+    };
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.toLowerCase().startsWith('system:')) {
+            pushMessage();
+            system = [{ text: trimmedLine.slice(7).trim() }];
+            currentRole = null;
+        }
+        else if (trimmedLine.toLowerCase().startsWith('user:')) {
+            pushMessage();
+            currentRole = 'user';
+            const content = trimmedLine.slice(5).trim();
+            if (content) {
+                currentContent.push(content);
+            }
+        }
+        else if (trimmedLine.toLowerCase().startsWith('assistant:')) {
+            pushMessage();
+            currentRole = 'assistant';
+            const content = trimmedLine.slice(10).trim();
+            if (content) {
+                currentContent.push(content);
+            }
+        }
+        else if (currentRole) {
+            currentContent.push(line);
+        }
+        else {
+            // No role prefix, treat as user message
+            currentRole = 'user';
+            currentContent.push(line);
+        }
+    }
+    pushMessage();
+    // If no messages were parsed, treat entire prompt as user message
+    if (messages.length === 0) {
+        messages.push({
+            role: 'user',
+            content: [{ text: prompt }],
+        });
+    }
+    return { messages, system };
+}
+/**
+ * Extract text output from Converse API response content blocks
+ */
+function extractTextFromContentBlocks(content, showThinking = true) {
+    const parts = [];
+    for (const block of content) {
+        if ('text' in block && block.text) {
+            parts.push(block.text);
+        }
+        else if ('reasoningContent' in block && block.reasoningContent) {
+            // Handle extended thinking content
+            const reasoning = block.reasoningContent;
+            if (showThinking) {
+                if ('reasoningText' in reasoning && reasoning.reasoningText) {
+                    const thinkingText = reasoning.reasoningText.text || '';
+                    const signature = reasoning.reasoningText.signature || '';
+                    parts.push(`<thinking>\n${thinkingText}\n</thinking>`);
+                    if (signature) {
+                        parts.push(`Signature: ${signature}`);
+                    }
+                }
+                else if ('redactedContent' in reasoning && reasoning.redactedContent) {
+                    parts.push('<thinking>[Redacted]</thinking>');
+                }
+            }
+        }
+        else if ('toolUse' in block && block.toolUse) {
+            // Format tool use for output
+            parts.push(JSON.stringify({
+                type: 'tool_use',
+                id: block.toolUse.toolUseId,
+                name: block.toolUse.name,
+                input: block.toolUse.input,
+            }));
+        }
+    }
+    return parts.join('\n\n');
+}
+/**
+ * AWS Bedrock Converse API Provider
+ */
+class AwsBedrockConverseProvider extends base_1.AwsBedrockGenericProvider {
+    constructor(modelName, options = {}) {
+        super(modelName, options);
+        this.loadedFunctionCallbacks = {};
+        this.config = options.config || {};
+        // Record telemetry
+        if (this.config.thinking) {
+            telemetry_1.default.record('feature_used', {
+                feature: 'extended_thinking',
+                provider: 'bedrock_converse',
+            });
+        }
+        if (this.config.tools) {
+            telemetry_1.default.record('feature_used', {
+                feature: 'tool_use',
+                provider: 'bedrock_converse',
+            });
+        }
+    }
+    id() {
+        return `bedrock:converse:${this.modelName}`;
+    }
+    toString() {
+        return `[AWS Bedrock Converse Provider ${this.modelName}]`;
+    }
+    /**
+     * Loads a function from an external file
+     * @param fileRef The file reference in the format 'file://path/to/file:functionName'
+     * @returns The loaded function
+     */
+    async loadExternalFunction(fileRef) {
+        let filePath = fileRef.slice('file://'.length);
+        let functionName;
+        if (filePath.includes(':')) {
+            const splits = filePath.split(':');
+            if (splits[0] && (0, fileExtensions_1.isJavascriptFile)(splits[0])) {
+                [filePath, functionName] = splits;
+            }
+        }
+        try {
+            const resolvedPath = path_1.default.resolve(cliState_1.default.basePath || '', filePath);
+            logger_1.default.debug(`[Bedrock Converse] Loading function from ${resolvedPath}${functionName ? `:${functionName}` : ''}`);
+            const requiredModule = await (0, esm_1.importModule)(resolvedPath, functionName);
+            if (typeof requiredModule === 'function') {
+                return requiredModule;
+            }
+            else if (requiredModule &&
+                typeof requiredModule === 'object' &&
+                functionName &&
+                functionName in requiredModule) {
+                const fn = requiredModule[functionName];
+                if (typeof fn === 'function') {
+                    return fn;
+                }
+            }
+            throw new Error(`Function callback malformed: ${filePath} must export ${functionName
+                ? `a named function '${functionName}'`
+                : 'a function or have a default export as a function'}`);
+        }
+        catch (error) {
+            throw new Error(`Error loading function from ${filePath}: ${error.message || String(error)}`);
+        }
+    }
+    /**
+     * Executes a function callback with proper error handling
+     */
+    async executeFunctionCallback(functionName, args) {
+        try {
+            // Check if we've already loaded this function
+            let callback = this.loadedFunctionCallbacks[functionName];
+            // If not loaded yet, try to load it now
+            if (!callback) {
+                const callbackRef = this.config.functionToolCallbacks?.[functionName];
+                if (callbackRef && typeof callbackRef === 'string') {
+                    const callbackStr = callbackRef;
+                    if (callbackStr.startsWith('file://')) {
+                        callback = await this.loadExternalFunction(callbackStr);
+                    }
+                    else {
+                        callback = new Function('return ' + callbackStr)();
+                    }
+                    // Cache for future use
+                    this.loadedFunctionCallbacks[functionName] = callback;
+                }
+                else if (typeof callbackRef === 'function') {
+                    callback = callbackRef;
+                    this.loadedFunctionCallbacks[functionName] = callback;
+                }
+            }
+            if (!callback) {
+                throw new Error(`No callback found for function '${functionName}'`);
+            }
+            // Execute the callback
+            logger_1.default.debug(`[Bedrock Converse] Executing function '${functionName}' with args: ${args}`);
+            const result = await callback(args);
+            // Format the result
+            if (result === undefined || result === null) {
+                return '';
+            }
+            else if (typeof result === 'object') {
+                try {
+                    return JSON.stringify(result);
+                }
+                catch (error) {
+                    logger_1.default.warn(`Error stringifying result from function '${functionName}': ${error}`);
+                    return String(result);
+                }
+            }
+            else {
+                return String(result);
+            }
+        }
+        catch (error) {
+            logger_1.default.error(`[Bedrock Converse] Error executing function '${functionName}': ${error.message || String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Build the inference configuration from options
+     */
+    buildInferenceConfig() {
+        const maxTokens = this.config.maxTokens ||
+            this.config.max_tokens ||
+            (0, envars_1.getEnvInt)('AWS_BEDROCK_MAX_TOKENS') ||
+            undefined;
+        const temperature = this.config.temperature ?? (0, envars_1.getEnvFloat)('AWS_BEDROCK_TEMPERATURE') ?? undefined;
+        const topP = this.config.topP || this.config.top_p || (0, envars_1.getEnvFloat)('AWS_BEDROCK_TOP_P');
+        let stopSequences = this.config.stopSequences || this.config.stop;
+        if (!stopSequences) {
+            const envStop = (0, envars_1.getEnvString)('AWS_BEDROCK_STOP');
+            if (envStop) {
+                try {
+                    stopSequences = JSON.parse(envStop);
+                }
+                catch {
+                    // Ignore invalid JSON
+                }
+            }
+        }
+        // Only return config if at least one field is set
+        if (maxTokens !== undefined ||
+            temperature !== undefined ||
+            topP !== undefined ||
+            stopSequences) {
+            return {
+                ...(maxTokens !== undefined ? { maxTokens } : {}),
+                ...(temperature !== undefined ? { temperature } : {}),
+                ...(topP !== undefined ? { topP } : {}),
+                ...(stopSequences ? { stopSequences } : {}),
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Build the tool configuration from options
+     */
+    async buildToolConfig(vars) {
+        if (!this.config.tools || this.config.tools.length === 0) {
+            return undefined;
+        }
+        // Load tools from external file with variable rendering if needed
+        const tools = await (0, index_1.maybeLoadToolsFromExternalFile)(this.config.tools, vars);
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        const converseTools = convertToolsToConverseFormat(tools);
+        const toolChoice = this.config.toolChoice
+            ? convertToolChoiceToConverseFormat(this.config.toolChoice)
+            : undefined;
+        return {
+            tools: converseTools,
+            ...(toolChoice ? { toolChoice } : {}),
+        };
+    }
+    /**
+     * Build the guardrail configuration
+     */
+    buildGuardrailConfig() {
+        if (!this.config.guardrailIdentifier) {
+            return undefined;
+        }
+        return {
+            guardrailIdentifier: String(this.config.guardrailIdentifier),
+            guardrailVersion: String(this.config.guardrailVersion || 'DRAFT'),
+            ...(this.config.trace ? { trace: this.config.trace } : {}),
+        };
+    }
+    /**
+     * Build additional model request fields (including thinking config)
+     */
+    buildAdditionalModelRequestFields() {
+        const fields = {
+            ...(this.config.additionalModelRequestFields || {}),
+        };
+        // Add thinking configuration for Claude models
+        if (this.config.thinking) {
+            fields.thinking = this.config.thinking;
+        }
+        return Object.keys(fields).length > 0 ? fields : undefined;
+    }
+    /**
+     * Build performance configuration
+     */
+    buildPerformanceConfig() {
+        if (!this.config.performanceConfig) {
+            return undefined;
+        }
+        return {
+            latency: this.config.performanceConfig.latency,
+        };
+    }
+    /**
+     * Build service tier configuration
+     */
+    buildServiceTier() {
+        if (!this.config.serviceTier) {
+            return undefined;
+        }
+        return {
+            type: this.config.serviceTier.type,
+        };
+    }
+    /**
+     * Main API call using Converse API
+     */
+    async callApi(prompt, context) {
+        // Parse the prompt into messages
+        const { messages, system } = parseConverseMessages(prompt);
+        // Build the request
+        const inferenceConfig = this.buildInferenceConfig();
+        const toolConfig = await this.buildToolConfig(context?.vars);
+        const guardrailConfig = this.buildGuardrailConfig();
+        const additionalModelRequestFields = this.buildAdditionalModelRequestFields();
+        const performanceConfig = this.buildPerformanceConfig();
+        const serviceTier = this.buildServiceTier();
+        const converseInput = {
+            modelId: this.modelName,
+            messages,
+            ...(system ? { system } : {}),
+            ...(inferenceConfig ? { inferenceConfig } : {}),
+            ...(toolConfig ? { toolConfig } : {}),
+            ...(guardrailConfig ? { guardrailConfig } : {}),
+            ...(additionalModelRequestFields ? { additionalModelRequestFields } : {}),
+            ...(this.config.additionalModelResponseFieldPaths
+                ? { additionalModelResponseFieldPaths: this.config.additionalModelResponseFieldPaths }
+                : {}),
+            ...(performanceConfig ? { performanceConfig } : {}),
+            ...(serviceTier ? { serviceTier } : {}),
+        };
+        logger_1.default.debug('Calling AWS Bedrock Converse API', {
+            modelId: this.modelName,
+            messageCount: messages.length,
+            hasSystem: !!system,
+            hasTools: !!toolConfig,
+            hasThinking: !!this.config.thinking,
+        });
+        // Check cache
+        const cache = await (0, cache_1.getCache)();
+        const cacheKey = `bedrock:converse:${this.modelName}:${JSON.stringify(converseInput)}`;
+        if ((0, cache_1.isCacheEnabled)()) {
+            const cachedResponse = await cache.get(cacheKey);
+            if (cachedResponse) {
+                logger_1.default.debug('Returning cached response');
+                const parsed = JSON.parse(cachedResponse);
+                return await this.parseResponse(parsed);
+            }
+        }
+        // Make the API call
+        let response;
+        try {
+            const bedrockInstance = await this.getBedrockInstance();
+            // Import and use ConverseCommand
+            const { ConverseCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-bedrock-runtime')));
+            const command = new ConverseCommand(converseInput);
+            response = await bedrockInstance.send(command);
+        }
+        catch (err) {
+            const errorMessage = err?.message || String(err);
+            logger_1.default.error('Bedrock Converse API error', { error: errorMessage });
+            // Provide helpful error messages for common issues
+            if (errorMessage.includes('ValidationException')) {
+                return {
+                    error: `Bedrock Converse API validation error: ${errorMessage}. Check that your model supports the Converse API and all parameters are valid.`,
+                };
+            }
+            if (errorMessage.includes('AccessDeniedException')) {
+                return {
+                    error: `Bedrock access denied: ${errorMessage}. Ensure you have bedrock:InvokeModel permission and model access is enabled.`,
+                };
+            }
+            return {
+                error: `Bedrock Converse API error: ${errorMessage}`,
+            };
+        }
+        // Cache the response
+        if ((0, cache_1.isCacheEnabled)()) {
+            try {
+                await cache.set(cacheKey, JSON.stringify(response));
+            }
+            catch (err) {
+                logger_1.default.error(`Failed to cache response: ${String(err)}`);
+            }
+        }
+        logger_1.default.debug('Bedrock Converse API response received', {
+            stopReason: response.stopReason,
+            hasUsage: !!response.usage,
+            hasMetrics: !!response.metrics,
+        });
+        return await this.parseResponse(response);
+    }
+    /**
+     * Parse the Converse API response into ProviderResponse format
+     */
+    async parseResponse(response) {
+        // Extract output text
+        const outputMessage = response.output?.message;
+        const content = outputMessage?.content || [];
+        const showThinking = this.config.showThinking !== false;
+        // Extract token usage
+        const usage = response.usage;
+        const promptTokens = usage?.inputTokens;
+        const completionTokens = usage?.outputTokens;
+        const totalTokens = usage?.totalTokens;
+        const cacheReadTokens = usage?.cacheReadInputTokens;
+        const cacheWriteTokens = usage?.cacheWriteInputTokens;
+        const tokenUsage = {
+            prompt: promptTokens,
+            completion: completionTokens,
+            total: totalTokens || (promptTokens || 0) + (completionTokens || 0),
+            numRequests: 1,
+        };
+        // Calculate cost
+        const cost = calculateBedrockConverseCost(this.modelName, promptTokens, completionTokens);
+        // Build metadata
+        const metadata = {};
+        // Add latency
+        if (response.metrics?.latencyMs) {
+            metadata.latencyMs = response.metrics.latencyMs;
+        }
+        // Add stop reason
+        if (response.stopReason) {
+            metadata.stopReason = response.stopReason;
+        }
+        // Add cache token info
+        if (cacheReadTokens !== undefined || cacheWriteTokens !== undefined) {
+            metadata.cacheTokens = {
+                read: cacheReadTokens,
+                write: cacheWriteTokens,
+            };
+        }
+        // Add performance config info
+        if (response.performanceConfig) {
+            metadata.performanceConfig = response.performanceConfig;
+        }
+        // Add service tier info
+        if (response.serviceTier) {
+            metadata.serviceTier = response.serviceTier;
+        }
+        // Add additional model response fields
+        if (response.additionalModelResponseFields) {
+            metadata.additionalModelResponseFields = response.additionalModelResponseFields;
+        }
+        // Add trace info if present
+        if (response.trace) {
+            metadata.trace = response.trace;
+        }
+        // Check for guardrail intervention
+        const guardrails = response.stopReason === 'guardrail_intervened'
+            ? { flagged: true, reason: 'guardrail_intervened' }
+            : undefined;
+        // Handle function tool callbacks if configured
+        if (this.config.functionToolCallbacks) {
+            const toolUseBlocks = content.filter((block) => 'toolUse' in block && block.toolUse !== undefined);
+            if (toolUseBlocks.length > 0) {
+                const results = [];
+                let hasSuccessfulCallback = false;
+                for (const block of toolUseBlocks) {
+                    const functionName = block.toolUse.name;
+                    if (functionName && this.config.functionToolCallbacks[functionName]) {
+                        try {
+                            const args = typeof block.toolUse.input === 'string'
+                                ? block.toolUse.input
+                                : JSON.stringify(block.toolUse.input || {});
+                            const result = await this.executeFunctionCallback(functionName, args);
+                            results.push(result);
+                            hasSuccessfulCallback = true;
+                        }
+                        catch (_error) {
+                            // If callback fails, fall back to original behavior
+                            logger_1.default.debug(`[Bedrock Converse] Function callback failed for ${functionName}, falling back to tool_use output`);
+                            hasSuccessfulCallback = false;
+                            break;
+                        }
+                    }
+                }
+                if (hasSuccessfulCallback && results.length > 0) {
+                    return {
+                        output: results.join('\n'),
+                        tokenUsage,
+                        ...(cost !== undefined ? { cost } : {}),
+                        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+                        ...(guardrails ? { guardrails } : {}),
+                    };
+                }
+            }
+        }
+        // Default output extraction
+        const output = extractTextFromContentBlocks(content, showThinking);
+        return {
+            output,
+            tokenUsage,
+            ...(cost !== undefined ? { cost } : {}),
+            ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+            ...(guardrails ? { guardrails } : {}),
+        };
+    }
+    /**
+     * Streaming API call using ConverseStream
+     *
+     * Note: functionToolCallbacks are not executed in streaming mode.
+     * Tool use blocks are captured and returned in the output, but callbacks
+     * are not automatically invoked. Use non-streaming mode if you need
+     * automatic tool callback execution.
+     */
+    async callApiStreaming(prompt, context) {
+        // Parse the prompt into messages
+        const { messages, system } = parseConverseMessages(prompt);
+        // Build the request (same as non-streaming)
+        const inferenceConfig = this.buildInferenceConfig();
+        const toolConfig = await this.buildToolConfig(context?.vars);
+        const guardrailConfig = this.buildGuardrailConfig();
+        const additionalModelRequestFields = this.buildAdditionalModelRequestFields();
+        const performanceConfig = this.buildPerformanceConfig();
+        const serviceTier = this.buildServiceTier();
+        const converseStreamInput = {
+            modelId: this.modelName,
+            messages,
+            ...(system ? { system } : {}),
+            ...(inferenceConfig ? { inferenceConfig } : {}),
+            ...(toolConfig ? { toolConfig } : {}),
+            ...(guardrailConfig ? { guardrailConfig } : {}),
+            ...(additionalModelRequestFields ? { additionalModelRequestFields } : {}),
+            ...(performanceConfig ? { performanceConfig } : {}),
+            ...(serviceTier ? { serviceTier } : {}),
+        };
+        logger_1.default.debug('Calling AWS Bedrock ConverseStream API', {
+            modelId: this.modelName,
+            messageCount: messages.length,
+        });
+        try {
+            const bedrockInstance = await this.getBedrockInstance();
+            const { ConverseStreamCommand } = await Promise.resolve().then(() => __importStar(require('@aws-sdk/client-bedrock-runtime')));
+            const command = new ConverseStreamCommand(converseStreamInput);
+            const response = await bedrockInstance.send(command);
+            // Collect the full response while also providing a stream
+            let output = '';
+            let reasoning = '';
+            let stopReason;
+            let usage = {};
+            // Track tool use blocks being streamed
+            const toolUseBlocks = new Map();
+            const showThinking = this.config.showThinking !== false;
+            // Process the stream
+            if (response.stream) {
+                for await (const event of response.stream) {
+                    // Handle content block start - includes tool use initialization
+                    if ('contentBlockStart' in event && event.contentBlockStart) {
+                        const blockIndex = event.contentBlockStart.contentBlockIndex ?? 0;
+                        const start = event.contentBlockStart.start;
+                        if (start && 'toolUse' in start && start.toolUse) {
+                            toolUseBlocks.set(blockIndex, {
+                                toolUseId: start.toolUse.toolUseId,
+                                name: start.toolUse.name,
+                                input: '',
+                            });
+                        }
+                    }
+                    if ('contentBlockDelta' in event && event.contentBlockDelta?.delta) {
+                        const delta = event.contentBlockDelta.delta;
+                        const blockIndex = event.contentBlockDelta.contentBlockIndex ?? 0;
+                        if ('text' in delta && delta.text) {
+                            output += delta.text;
+                        }
+                        if ('reasoningContent' in delta && delta.reasoningContent && showThinking) {
+                            const rc = delta.reasoningContent;
+                            if (rc.text) {
+                                reasoning += rc.text;
+                            }
+                        }
+                        // Handle streaming tool use input
+                        if ('toolUse' in delta && delta.toolUse) {
+                            const toolBlock = toolUseBlocks.get(blockIndex);
+                            if (toolBlock && delta.toolUse.input) {
+                                toolBlock.input += delta.toolUse.input;
+                            }
+                        }
+                    }
+                    if ('messageStop' in event && event.messageStop) {
+                        stopReason = event.messageStop.stopReason;
+                    }
+                    if ('metadata' in event && event.metadata?.usage) {
+                        usage = event.metadata.usage;
+                    }
+                }
+            }
+            // Format tool use blocks for output (same as non-streaming)
+            const toolUseParts = [];
+            for (const [, toolBlock] of toolUseBlocks) {
+                if (toolBlock.name) {
+                    let parsedInput;
+                    try {
+                        parsedInput = toolBlock.input ? JSON.parse(toolBlock.input) : {};
+                    }
+                    catch {
+                        parsedInput = toolBlock.input;
+                    }
+                    toolUseParts.push(JSON.stringify({
+                        type: 'tool_use',
+                        id: toolBlock.toolUseId,
+                        name: toolBlock.name,
+                        input: parsedInput,
+                    }));
+                }
+            }
+            // Combine reasoning, output, and tool use
+            const parts = [];
+            if (reasoning) {
+                parts.push(`<thinking>\n${reasoning}\n</thinking>`);
+            }
+            if (output) {
+                parts.push(output);
+            }
+            if (toolUseParts.length > 0) {
+                parts.push(...toolUseParts);
+            }
+            const finalOutput = parts.join('\n\n');
+            const tokenUsage = {
+                prompt: usage.inputTokens,
+                completion: usage.outputTokens,
+                total: usage.totalTokens || (usage.inputTokens || 0) + (usage.outputTokens || 0),
+                numRequests: 1,
+            };
+            const cost = calculateBedrockConverseCost(this.modelName, usage.inputTokens, usage.outputTokens);
+            return {
+                output: finalOutput,
+                tokenUsage,
+                ...(cost !== undefined ? { cost } : {}),
+                ...(stopReason ? { metadata: { stopReason } } : {}),
+            };
+        }
+        catch (err) {
+            return {
+                error: `Bedrock ConverseStream API error: ${err?.message || String(err)}`,
+            };
+        }
+    }
+}
+exports.AwsBedrockConverseProvider = AwsBedrockConverseProvider;
+//# sourceMappingURL=converse.js.map