promptfoo 0.125.0 → 0.125.1

package/dist/src/aws-qskKGczY.cjs

@@ -0,0 +1,2454 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+require("./dataUrl-BdHUey2l.cjs");
+const require_shared = require("./shared-D9Bf3UgD.cjs");
+const require_file = require("./file-CPfaem7U.cjs");
+const require_providerRegistry = require("./providerRegistry-CAn7vpBJ.cjs");
+const require_genaiTracer = require("./genaiTracer-C32xFIB8.cjs");
+const require_cache = require("./cache-iG87oYan.cjs");
+const require_util = require("./util-ClJRjlQA.cjs");
+const require_tokenUsageUtils = require("./tokenUsageUtils-DMF9uhT9.cjs");
+const require_functionCallbackUtils = require("./functionCallbackUtils-BB9tmf6a.cjs");
+const require_client = require("./client-BktbiPx9.cjs");
+const require_util$1 = require("./util-CICwIpmu.cjs");
+const require_routing = require("./routing-Bu7xmjM1.cjs");
+const require_telemetry = require("./telemetry-C04d25BM.cjs");
+const require_base = require("./base-RRYXfG7l.cjs");
+const require_pricing = require("./pricing-0Pampf0q.cjs");
+let dedent = require("dedent");
+dedent = require_rolldown_runtime.__toESM(dedent, 1);
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = require_rolldown_runtime.__toESM(_anthropic_ai_sdk, 1);
+//#region src/providers/bedrock/index.ts
+const coerceStrToNum = (value) => value === void 0 ? void 0 : typeof value === "string" ? Number(value) : value;
+function getNovaTokenUsage(responseJson) {
+	const usage = responseJson?.usage;
+	if (!usage) return missingBedrockTokenUsage();
+	return {
+		prompt: coerceStrToNum(usage.inputTokens),
+		completion: coerceStrToNum(usage.outputTokens),
+		total: coerceStrToNum(usage.totalTokens),
+		numRequests: 1
+	};
+}
+function getCohereTokenUsage(responseJson) {
+	if (responseJson?.meta?.billed_units) {
+		const inputTokens = coerceStrToNum(responseJson.meta.billed_units.input_tokens);
+		const outputTokens = coerceStrToNum(responseJson.meta.billed_units.output_tokens);
+		return {
+			prompt: inputTokens,
+			completion: outputTokens,
+			total: (inputTokens ?? 0) + (outputTokens ?? 0),
+			numRequests: 1
+		};
+	}
+	return missingBedrockTokenUsage();
+}
+function missingBedrockTokenUsage() {
+	return {
+		prompt: void 0,
+		completion: void 0,
+		total: void 0,
+		numRequests: 1
+	};
+}
+function parseValue(value, defaultValue) {
+	if (typeof defaultValue === "number") {
+		if (typeof value === "string") return Number.isNaN(Number.parseFloat(value)) ? defaultValue : Number.parseFloat(value);
+		return value;
+	}
+	return value;
+}
+function addConfigParam(params, key, configValue, envValue, defaultValue) {
+	if (configValue !== void 0 || envValue !== void 0 || defaultValue !== void 0) params[key] = configValue ?? (envValue === void 0 ? defaultValue : parseValue(envValue, defaultValue));
+}
+function getOpenAiCompatibleTokenUsage(responseJson, _promptText) {
+	const usage = responseJson?.usage;
+	return {
+		prompt: coerceStrToNum(usage?.prompt_tokens),
+		completion: coerceStrToNum(usage?.completion_tokens),
+		total: coerceStrToNum(usage?.total_tokens),
+		numRequests: 1
+	};
+}
+const BEDROCK_MISTRAL_CHAT_MODEL = {
+	params: async (config, prompt, stop, _modelName) => {
+		const params = { messages: require_shared.parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]) };
+		addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("MISTRAL_MAX_TOKENS"), 1024);
+		addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("MISTRAL_TEMPERATURE"), 0);
+		addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("MISTRAL_TOP_P"), 1);
+		if (stop && stop.length > 0) addConfigParam(params, "stop", stop);
+		return params;
+	},
+	output: (_config, responseJson) => {
+		if (responseJson?.choices && Array.isArray(responseJson.choices)) return responseJson.choices[0]?.message?.content;
+	},
+	tokenUsage: (responseJson, _promptText) => {
+		if (responseJson?.prompt_tokens !== void 0 && responseJson?.completion_tokens !== void 0) {
+			const promptTokens = coerceStrToNum(responseJson.prompt_tokens);
+			const completionTokens = coerceStrToNum(responseJson.completion_tokens);
+			return {
+				prompt: promptTokens,
+				completion: completionTokens,
+				total: (promptTokens ?? 0) + (completionTokens ?? 0),
+				numRequests: 1
+			};
+		}
+		if (responseJson?.usage?.prompt_tokens !== void 0 && responseJson?.usage?.completion_tokens !== void 0) {
+			const promptTokens = coerceStrToNum(responseJson.usage.prompt_tokens);
+			const completionTokens = coerceStrToNum(responseJson.usage.completion_tokens);
+			return {
+				prompt: promptTokens,
+				completion: completionTokens,
+				total: coerceStrToNum(responseJson.usage.total_tokens) ?? (promptTokens !== void 0 && completionTokens !== void 0 ? promptTokens + completionTokens : void 0),
+				numRequests: 1
+			};
+		}
+		return missingBedrockTokenUsage();
+	}
+};
+const BEDROCK_DEEPSEEK_CHAT_MODEL = {
+	params: async (config, prompt, stop, _modelName) => {
+		const params = { messages: require_shared.parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]) };
+		addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+		addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+		addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+		if (stop && stop.length > 0) addConfigParam(params, "stop", stop);
+		return params;
+	},
+	output: (_config, responseJson) => {
+		if (responseJson.error) throw new Error(`DeepSeek API error: ${responseJson.error}`);
+		return responseJson.choices?.[0]?.message?.content;
+	},
+	tokenUsage: getOpenAiCompatibleTokenUsage
+};
+const LlamaVersion = {
+	V2: 2,
+	V3: 3,
+	V3_1: 3.1,
+	V3_2: 3.2,
+	V3_3: 3.3,
+	V4: 4
+};
+/**
+* Extracts base64 image data from an image block.
+* Handles multiple formats: data URL, source.bytes, source.data, image_url.url
+*/
+function extractImageData(block) {
+	const imageUrl = block.image_url?.url || block.type === "image_url" && block.url;
+	if (typeof imageUrl === "string" && imageUrl.startsWith("data:")) {
+		const matches = imageUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
+		if (matches) return matches[1];
+	}
+	const imageData = block.image || block;
+	if (imageData.source?.bytes) {
+		const rawBytes = imageData.source.bytes;
+		if (typeof rawBytes === "string") {
+			if (rawBytes.startsWith("data:")) {
+				const matches = rawBytes.match(/^data:image\/[^;]+;base64,(.+)$/);
+				if (matches) return matches[1];
+			}
+			return rawBytes;
+		} else if (Buffer.isBuffer(rawBytes)) return rawBytes.toString("base64");
+	}
+	if (imageData.source?.data) {
+		const data = imageData.source.data;
+		if (data.startsWith("data:")) {
+			const matches = data.match(/^data:image\/[^;]+;base64,(.+)$/);
+			if (matches) return matches[1];
+		}
+		return data;
+	}
+	return null;
+}
+/**
+* Extracts text and images from message content for Llama 3.2 Vision.
+* Returns text with <|image|> tokens at image positions, plus base64 images array.
+*
+* @param content - The message content (string or array of content blocks)
+* @returns ExtractedContent with text (including image tokens) and images array
+*/
+function extractTextAndImages(content) {
+	if (typeof content === "string") return {
+		text: content.trim(),
+		images: []
+	};
+	if (Array.isArray(content)) {
+		const parts = [];
+		const images = [];
+		for (const block of content) if (typeof block === "string") parts.push(block);
+		else if (block.type === "text" && block.text) parts.push(block.text);
+		else if (block.text && !block.type) parts.push(block.text);
+		else if (block.type === "image" || block.type === "image_url" || block.image || block.image_url) {
+			const imageData = extractImageData(block);
+			if (imageData) {
+				images.push(imageData);
+				parts.push("<|image|>");
+			}
+		}
+		return {
+			text: parts.join("").trim(),
+			images
+		};
+	}
+	return {
+		text: String(content).trim(),
+		images: []
+	};
+}
+/**
+* Extracts text content from a message, handling both string and array formats.
+* Throws an error if the content contains non-text items (images, etc.) since
+* the legacy InvokeModel API doesn't support multimodal content.
+*
+* @param content - The message content (string or array of content blocks)
+* @param modelName - The model name for error messaging
+* @returns The extracted text content as a string
+* @throws Error if multimodal content is detected
+*/
+function extractTextContent(content, modelName) {
+	if (typeof content === "string") return content.trim();
+	if (Array.isArray(content)) {
+		const textParts = [];
+		let hasNonTextContent = false;
+		for (const block of content) if (typeof block === "string") textParts.push(block);
+		else if (block.type === "text" && block.text) textParts.push(block.text);
+		else if (block.text && !block.type) textParts.push(block.text);
+		else if (block.type === "image" || block.type === "image_url" || block.image || block.image_url) hasNonTextContent = true;
+		if (hasNonTextContent) {
+			const modelInfo = modelName ? ` (${modelName})` : "";
+			throw new Error(`Multimodal content (images) detected but the legacy Bedrock Llama provider${modelInfo} does not support images. Please use the Converse API provider instead:\n\n  Change: bedrock:${modelName || "<model-id>"}\n  To:     bedrock:converse:${modelName || "<model-id>"}\n\nThe Converse API supports multimodal content for vision-capable models like Llama 3.2 11B/90B.`);
+		}
+		return textParts.join(" ").trim();
+	}
+	return String(content).trim();
+}
+const formatPromptLlama2Chat = (messages, modelName) => {
+	if (messages.length === 0) return "";
+	let formattedPrompt = "<s>";
+	let systemMessageIncluded = false;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		const textContent = extractTextContent(message.content, modelName);
+		switch (message.role) {
+			case "system":
+				if (!systemMessageIncluded) {
+					formattedPrompt += `[INST] <<SYS>>\n${textContent}\n<</SYS>>\n\n`;
+					systemMessageIncluded = true;
+				}
+				break;
+			case "user":
+				if (i === 0 && !systemMessageIncluded) formattedPrompt += `[INST] ${textContent} [/INST]`;
+				else if (i === 0 && systemMessageIncluded) formattedPrompt += `${textContent} [/INST]`;
+				else if (i > 0 && messages[i - 1].role === "assistant") formattedPrompt += `<s>[INST] ${textContent} [/INST]`;
+				else formattedPrompt += `${textContent} [/INST]`;
+				break;
+			case "assistant":
+				formattedPrompt += ` ${textContent} </s>`;
+				break;
+			default: throw new Error(`Unexpected role: ${message.role}`);
+		}
+	}
+	return formattedPrompt;
+};
+const formatPromptLlama3Instruct = (messages, modelName) => {
+	let formattedPrompt = "<|begin_of_text|>";
+	for (const message of messages) {
+		const textContent = extractTextContent(message.content, modelName);
+		formattedPrompt += dedent.default`
+      <|start_header_id|>${message.role}<|end_header_id|>
+
+      ${textContent}<|eot_id|>`;
+	}
+	formattedPrompt += "<|start_header_id|>assistant<|end_header_id|>";
+	return formattedPrompt;
+};
+/**
+* Formats a Llama 3.2 Vision prompt with images.
+* Extracts images from messages and inserts <|image|> tokens at appropriate positions.
+*
+* @param messages - Array of chat messages
+* @returns Object containing the formatted prompt and array of base64 images
+*/
+const formatPromptLlama32Vision = (messages) => {
+	let formattedPrompt = "<|begin_of_text|>";
+	const allImages = [];
+	for (const message of messages) {
+		const { text, images } = extractTextAndImages(message.content);
+		allImages.push(...images);
+		formattedPrompt += dedent.default`
+      <|start_header_id|>${message.role}<|end_header_id|>
+
+      ${text}<|eot_id|>`;
+	}
+	formattedPrompt += "<|start_header_id|>assistant<|end_header_id|>";
+	return {
+		prompt: formattedPrompt,
+		images: allImages
+	};
+};
+const formatPromptLlama4 = (messages, modelName) => {
+	let formattedPrompt = "<|begin_of_text|>";
+	for (const message of messages) {
+		const textContent = extractTextContent(message.content, modelName);
+		formattedPrompt += dedent.default`<|header_start|>${message.role}<|header_end|>
+
+${textContent}<|eot|>`;
+	}
+	formattedPrompt += "<|header_start|>assistant<|header_end|>";
+	return formattedPrompt;
+};
+const getLlamaModelHandler = (version) => {
+	if (![
+		LlamaVersion.V2,
+		LlamaVersion.V3,
+		LlamaVersion.V3_1,
+		LlamaVersion.V3_2,
+		LlamaVersion.V3_3,
+		LlamaVersion.V4
+	].includes(version)) throw new Error(`Unsupported LLAMA version: ${version}`);
+	return {
+		params: async (config, prompt, _stop, modelName) => {
+			const messages = require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]);
+			let finalPrompt;
+			let images = [];
+			switch (version) {
+				case LlamaVersion.V2:
+					finalPrompt = formatPromptLlama2Chat(messages, modelName);
+					break;
+				case LlamaVersion.V3:
+				case LlamaVersion.V3_1:
+				case LlamaVersion.V3_3:
+					finalPrompt = formatPromptLlama3Instruct(messages, modelName);
+					break;
+				case LlamaVersion.V3_2:
+					if (modelName && (/11b/i.test(modelName) || /90b/i.test(modelName))) {
+						const result = formatPromptLlama32Vision(messages);
+						finalPrompt = result.prompt;
+						images = result.images;
+					} else finalPrompt = formatPromptLlama3Instruct(messages, modelName);
+					break;
+				case LlamaVersion.V4:
+					finalPrompt = formatPromptLlama4(messages, modelName);
+					break;
+				default: throw new Error(`Unsupported LLAMA version: ${version}`);
+			}
+			const params = { prompt: finalPrompt };
+			if (images.length > 0) params.images = images;
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(params, "max_gen_len", config?.max_gen_len, require_logger.getEnvInt("AWS_BEDROCK_MAX_GEN_LEN"), 1024);
+			return params;
+		},
+		output: (_config, responseJson) => responseJson?.generation,
+		tokenUsage: (responseJson, _promptText) => {
+			if (responseJson?.usage) return {
+				prompt: coerceStrToNum(responseJson.usage.prompt_tokens),
+				completion: coerceStrToNum(responseJson.usage.completion_tokens),
+				total: coerceStrToNum(responseJson.usage.total_tokens),
+				numRequests: 1
+			};
+			const promptTokens = responseJson?.prompt_token_count;
+			const completionTokens = responseJson?.generation_token_count;
+			if (promptTokens !== void 0 && completionTokens !== void 0) {
+				const promptTokensNum = coerceStrToNum(promptTokens);
+				const completionTokensNum = coerceStrToNum(completionTokens);
+				return {
+					prompt: promptTokensNum,
+					completion: completionTokensNum,
+					total: (promptTokensNum ?? 0) + (completionTokensNum ?? 0),
+					numRequests: 1
+				};
+			}
+			return missingBedrockTokenUsage();
+		}
+	};
+};
+const BEDROCK_MODEL = {
+	AI21: {
+		params: async (config, prompt, _stop, _modelName) => {
+			const params = { messages: require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(params, "stop", config?.stop, require_logger.getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, require_logger.getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, require_logger.getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			return params;
+		},
+		output: (_config, responseJson) => {
+			if (responseJson.error) throw new Error(`AI21 API error: ${responseJson.error}`);
+			return responseJson.choices?.[0]?.message?.content;
+		},
+		tokenUsage: getOpenAiCompatibleTokenUsage
+	},
+	AMAZON_NOVA: {
+		params: async (config, prompt, _stop, _modelName) => {
+			let messages;
+			let systemPrompt;
+			try {
+				const parsed = JSON.parse(prompt);
+				if (Array.isArray(parsed)) {
+					messages = parsed.map((msg) => ({
+						role: msg.role,
+						content: Array.isArray(msg.content) ? msg.content : [{ text: msg.content }]
+					})).filter((msg) => msg.role !== "system");
+					const systemMessage = parsed.find((msg) => msg.role === "system");
+					if (systemMessage) systemPrompt = [{ text: systemMessage.content }];
+				} else {
+					const { system, extractedMessages } = require_base.novaParseMessages(prompt);
+					messages = extractedMessages;
+					if (system) systemPrompt = [{ text: system }];
+				}
+			} catch {
+				const { system, extractedMessages } = require_base.novaParseMessages(prompt);
+				messages = extractedMessages;
+				if (system) systemPrompt = [{ text: system }];
+			}
+			const params = { messages };
+			if (systemPrompt) addConfigParam(params, "system", systemPrompt, void 0, void 0);
+			const inferenceConfig = config.interfaceConfig ? { ...config.interfaceConfig } : {};
+			addConfigParam(inferenceConfig, "max_new_tokens", config?.interfaceConfig?.max_new_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(inferenceConfig, "temperature", config?.interfaceConfig?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "inferenceConfig", inferenceConfig, void 0, void 0);
+			addConfigParam(params, "toolConfig", config.toolConfig, void 0, void 0);
+			return params;
+		},
+		output: (_config, responseJson) => require_base.novaOutputFromMessage(responseJson),
+		tokenUsage: (responseJson, _promptText) => getNovaTokenUsage(responseJson)
+	},
+	/**
+	* Amazon Nova 2 model handler with extended thinking (reasoning) support.
+	* Supports reasoningConfig with maxReasoningEffort levels: low, medium, high.
+	*/
+	AMAZON_NOVA_2: {
+		params: async (config, prompt, _stop, _modelName) => {
+			let messages;
+			let systemPrompt;
+			try {
+				const parsed = JSON.parse(prompt);
+				if (Array.isArray(parsed)) {
+					messages = parsed.map((msg) => ({
+						role: msg.role,
+						content: Array.isArray(msg.content) ? msg.content : [{ text: msg.content }]
+					})).filter((msg) => msg.role !== "system");
+					const systemMessage = parsed.find((msg) => msg.role === "system");
+					if (systemMessage) systemPrompt = [{ text: systemMessage.content }];
+				} else {
+					const { system, extractedMessages } = require_base.novaParseMessages(prompt);
+					messages = extractedMessages;
+					if (system) systemPrompt = [{ text: system }];
+				}
+			} catch {
+				const { system, extractedMessages } = require_base.novaParseMessages(prompt);
+				messages = extractedMessages;
+				if (system) systemPrompt = [{ text: system }];
+			}
+			const params = { messages };
+			if (systemPrompt) addConfigParam(params, "system", systemPrompt, void 0, void 0);
+			const reasoningEnabled = config.reasoningConfig?.type === "enabled";
+			const isHighEffort = config.reasoningConfig?.maxReasoningEffort === "high";
+			const inferenceConfig = {};
+			if (config.interfaceConfig) {
+				const { max_new_tokens: _maxTokens, temperature: _temp, ...otherParams } = config.interfaceConfig;
+				Object.assign(inferenceConfig, otherParams);
+			}
+			if (!(reasoningEnabled && isHighEffort)) addConfigParam(inferenceConfig, "max_new_tokens", config?.interfaceConfig?.max_new_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			if (!reasoningEnabled) addConfigParam(inferenceConfig, "temperature", config?.interfaceConfig?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "inferenceConfig", inferenceConfig, void 0, void 0);
+			addConfigParam(params, "toolConfig", config.toolConfig, void 0, void 0);
+			if (config.reasoningConfig) addConfigParam(params, "reasoningConfig", config.reasoningConfig, void 0, void 0);
+			return params;
+		},
+		output: (config, responseJson) => {
+			const content = responseJson.output?.message?.content;
+			if (!content || !Array.isArray(content)) return require_base.novaOutputFromMessage(responseJson);
+			if (content.some((block) => block.toolUse?.toolUseId)) return content.map((block) => {
+				if (block.text) return null;
+				return JSON.stringify(block.toolUse);
+			}).filter((block) => block).join("\n\n");
+			const parts = [];
+			const showThinking = config.showThinking !== false;
+			for (const block of content) if (block.reasoningContent && showThinking) {
+				const reasoningText = block.reasoningContent?.reasoningText?.text;
+				if (reasoningText) parts.push(`<thinking>\n${reasoningText}\n</thinking>`);
+			} else if (block.text) parts.push(block.text);
+			return parts.join("\n\n");
+		},
+		tokenUsage: (responseJson, _promptText) => getNovaTokenUsage(responseJson)
+	},
+	CLAUDE_COMPLETION: {
+		params: async (config, prompt, stop, _modelName) => {
+			const params = {
+				prompt: `${_anthropic_ai_sdk.default.HUMAN_PROMPT} ${prompt} ${_anthropic_ai_sdk.default.AI_PROMPT}`,
+				stop_sequences: stop
+			};
+			addConfigParam(params, "max_tokens_to_sample", config?.max_tokens_to_sample, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), 1024);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			return params;
+		},
+		output: (_config, responseJson) => responseJson?.completion,
+		tokenUsage: (responseJson, _promptText) => {
+			if (!responseJson?.usage) return missingBedrockTokenUsage();
+			const usage = responseJson.usage;
+			const inputTokens = usage.input_tokens || usage.prompt_tokens;
+			const inputTokensNum = coerceStrToNum(inputTokens);
+			const outputTokens = usage.output_tokens || usage.completion_tokens;
+			const outputTokensNum = coerceStrToNum(outputTokens);
+			let totalTokens = usage.totalTokens || usage.total_tokens;
+			if (totalTokens == null && inputTokensNum !== void 0 && outputTokensNum !== void 0) totalTokens = inputTokensNum + outputTokensNum;
+			return {
+				prompt: inputTokensNum,
+				completion: outputTokensNum,
+				total: coerceStrToNum(totalTokens),
+				numRequests: 1
+			};
+		}
+	},
+	CLAUDE_MESSAGES: {
+		params: async (config, prompt, _stop, modelName, vars) => {
+			let messages;
+			let systemPrompt;
+			try {
+				const parsed = JSON.parse(prompt);
+				if (Array.isArray(parsed)) {
+					const systemMessages = parsed.filter((msg) => msg.role === "system");
+					const nonSystemMessages = parsed.filter((msg) => msg.role !== "system");
+					if (systemMessages.length === 1 && nonSystemMessages.length === 0) {
+						messages = [{
+							role: "user",
+							content: Array.isArray(systemMessages[0].content) ? systemMessages[0].content : [{
+								type: "text",
+								text: systemMessages[0].content
+							}]
+						}];
+						systemPrompt = void 0;
+					} else {
+						messages = nonSystemMessages.map((msg) => ({
+							role: msg.role,
+							content: Array.isArray(msg.content) ? msg.content : [{
+								type: "text",
+								text: msg.content
+							}]
+						}));
+						systemPrompt = systemMessages[0]?.content;
+					}
+				} else {
+					const { system, extractedMessages } = require_util$1.parseMessages(prompt);
+					messages = extractedMessages;
+					systemPrompt = system;
+				}
+			} catch {
+				const { system, extractedMessages } = require_util$1.parseMessages(prompt);
+				messages = extractedMessages;
+				systemPrompt = system;
+			}
+			const params = { messages };
+			addConfigParam(params, "anthropic_version", config?.anthropic_version, void 0, "bedrock-2023-05-31");
+			const alwaysOnAdaptiveThinking = !!modelName && require_util$1.isAlwaysOnAdaptiveThinkingClaudeModel(modelName);
+			const thinksByDefault = alwaysOnAdaptiveThinking || !!modelName && require_util$1.isThinkingOnByDefaultClaudeModel(modelName) && config?.thinking?.type !== "disabled" && config?.thinking?.type !== "between_tools";
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), thinksByDefault ? 2048 : 1024);
+			const thinking = modelName ? require_util$1.normalizeClaudeThinkingConfig(modelName, config?.thinking, void 0) : config?.thinking;
+			const { sampling, warnings: samplingWarnings } = require_util$1.resolveClaudeSamplingParams({ temperature: config?.temperature }, {
+				thinkingEnabled: alwaysOnAdaptiveThinking || require_util$1.isClaudeThinkingEnabled(thinking),
+				samplingParamsDeprecated: modelName ? require_util$1.isSamplingParamsDeprecatedClaudeModel(modelName) : false,
+				defaultTemperature: 0
+			});
+			for (const warning of samplingWarnings) require_logger.logger.warn(warning);
+			addConfigParam(params, "temperature", sampling.temperature, void 0, void 0);
+			addConfigParam(params, "tools", await require_file.maybeLoadToolsFromExternalFile(config?.tools, vars), void 0, void 0);
+			addConfigParam(params, "tool_choice", (alwaysOnAdaptiveThinking || !!modelName && require_util$1.isForcedToolChoiceUnsupportedClaudeModel(modelName)) && (config?.tool_choice?.type === "any" || config?.tool_choice?.type === "tool") ? void 0 : config?.tool_choice, void 0, void 0);
+			addConfigParam(params, "thinking", thinking, void 0, void 0);
+			if (typeof params.max_tokens === "number") params.max_tokens = require_util$1.clampMaxTokensForThinkingBudget(params.max_tokens, thinking);
+			if (systemPrompt) addConfigParam(params, "system", systemPrompt, void 0, void 0);
+			return params;
+		},
+		output: (config, responseJson) => {
+			return require_util$1.outputFromMessage(responseJson, config?.showThinking ?? true);
+		},
+		tokenUsage: (responseJson, _promptText) => {
+			if (!responseJson?.usage) return missingBedrockTokenUsage();
+			const usage = responseJson.usage;
+			const normalizedUsage = {
+				...usage,
+				input_tokens: usage.input_tokens ?? usage.prompt_tokens,
+				output_tokens: usage.output_tokens ?? usage.completion_tokens
+			};
+			return {
+				...require_util$1.getTokenUsage({ usage: normalizedUsage }, false),
+				numRequests: 1
+			};
+		}
+	},
+	TITAN_TEXT: {
+		params: async (config, prompt, stop, _modelName) => {
+			const textGenerationConfig = {};
+			addConfigParam(textGenerationConfig, "maxTokenCount", config?.textGenerationConfig?.maxTokenCount, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), 1024);
+			addConfigParam(textGenerationConfig, "temperature", config?.textGenerationConfig?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(textGenerationConfig, "topP", config?.textGenerationConfig?.topP, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(textGenerationConfig, "stopSequences", config?.textGenerationConfig?.stopSequences, void 0, stop);
+			return {
+				inputText: prompt,
+				textGenerationConfig
+			};
+		},
+		output: (_config, responseJson) => responseJson?.results?.[0]?.outputText,
+		tokenUsage: getOpenAiCompatibleTokenUsage
+	},
+	LLAMA2: getLlamaModelHandler(LlamaVersion.V2),
+	LLAMA3: getLlamaModelHandler(LlamaVersion.V3),
+	LLAMA3_1: getLlamaModelHandler(LlamaVersion.V3_1),
+	LLAMA3_2: getLlamaModelHandler(LlamaVersion.V3_2),
+	LLAMA3_3: getLlamaModelHandler(LlamaVersion.V3_3),
+	LLAMA4: getLlamaModelHandler(LlamaVersion.V4),
+	COHERE_COMMAND: {
+		params: async (config, prompt, stop, _modelName) => {
+			const params = { prompt };
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("COHERE_TEMPERATURE"), 0);
+			addConfigParam(params, "p", config?.p, require_logger.getEnvFloat("COHERE_P"), 1);
+			addConfigParam(params, "k", config?.k, require_logger.getEnvInt("COHERE_K"), 0);
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("COHERE_MAX_TOKENS"), 1024);
+			addConfigParam(params, "return_likelihoods", config?.return_likelihoods, void 0, "NONE");
+			addConfigParam(params, "stream", config?.stream, void 0, false);
+			addConfigParam(params, "num_generations", config?.num_generations, void 0, 1);
+			addConfigParam(params, "logit_bias", config?.logit_bias, void 0, {});
+			addConfigParam(params, "truncate", config?.truncate, void 0, "NONE");
+			addConfigParam(params, "stop_sequences", stop, void 0, void 0);
+			return params;
+		},
+		output: (_config, responseJson) => responseJson?.generations?.[0]?.text,
+		tokenUsage: (responseJson, _promptText) => getCohereTokenUsage(responseJson)
+	},
+	COHERE_COMMAND_R: {
+		params: async (config, prompt, stop, _modelName, vars) => {
+			const messages = require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]);
+			const lastMessage = messages[messages.length - 1].content;
+			if (!messages.every((m) => typeof m.content === "string")) throw new Error(`Message content must be a string, but got: ${JSON.stringify(messages)}`);
+			const params = {
+				message: lastMessage,
+				chat_history: messages.slice(0, messages.length - 1).map((m) => ({
+					role: m.role === "assistant" ? "CHATBOT" : "USER",
+					message: m.content
+				}))
+			};
+			addConfigParam(params, "documents", config?.documents);
+			addConfigParam(params, "search_queries_only", config?.search_queries_only);
+			addConfigParam(params, "preamble", config?.preamble);
+			addConfigParam(params, "max_tokens", config?.max_tokens);
+			addConfigParam(params, "temperature", config?.temperature);
+			addConfigParam(params, "p", config?.p);
+			addConfigParam(params, "k", config?.k);
+			addConfigParam(params, "prompt_truncation", config?.prompt_truncation);
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty);
+			addConfigParam(params, "presence_penalty", config?.presence_penalty);
+			addConfigParam(params, "seed", config?.seed);
+			addConfigParam(params, "return_prompt", config?.return_prompt);
+			addConfigParam(params, "tools", await require_file.maybeLoadToolsFromExternalFile(config?.tools, vars));
+			addConfigParam(params, "tool_results", config?.tool_results);
+			addConfigParam(params, "stop_sequences", stop);
+			addConfigParam(params, "raw_prompting", config?.raw_prompting);
+			return params;
+		},
+		output: (_config, responseJson) => responseJson?.text,
+		tokenUsage: (responseJson, _promptText) => getCohereTokenUsage(responseJson)
+	},
+	DEEPSEEK: {
+		params: async (config, prompt, _stop, _modelName) => {
+			const params = { prompt: `
+${prompt}
+<think>\n` };
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			return params;
+		},
+		output: (config, responseJson) => {
+			if (responseJson.error) throw new Error(`DeepSeek API error: ${responseJson.error}`);
+			if (responseJson.choices && Array.isArray(responseJson.choices)) {
+				const choice = responseJson.choices[0];
+				if (choice && choice.text) {
+					const fullResponse = choice.text;
+					const [thinking, finalResponse] = fullResponse.split("</think>");
+					if (!thinking || !finalResponse) return fullResponse;
+					if (config.showThinking !== false) return fullResponse;
+					return finalResponse.trim();
+				}
+			}
+		},
+		tokenUsage: getOpenAiCompatibleTokenUsage
+	},
+	MISTRAL: {
+		params: async (config, prompt, stop, _modelName) => {
+			const params = {
+				prompt,
+				stop
+			};
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("MISTRAL_MAX_TOKENS"), 1024);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("MISTRAL_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("MISTRAL_TOP_P"), 1);
+			addConfigParam(params, "top_k", config?.top_k, require_logger.getEnvFloat("MISTRAL_TOP_K"));
+			return params;
+		},
+		output: (_config, responseJson) => {
+			if (!responseJson?.outputs || !Array.isArray(responseJson.outputs)) return;
+			return responseJson.outputs[0]?.text;
+		},
+		tokenUsage: (responseJson, _promptText) => {
+			if (responseJson?.usage) return {
+				prompt: coerceStrToNum(responseJson.usage.prompt_tokens),
+				completion: coerceStrToNum(responseJson.usage.completion_tokens),
+				total: coerceStrToNum(responseJson.usage.total_tokens),
+				numRequests: 1
+			};
+			if (responseJson?.prompt_tokens !== void 0 && responseJson?.completion_tokens !== void 0) {
+				const promptTokens = coerceStrToNum(responseJson.prompt_tokens);
+				const completionTokens = coerceStrToNum(responseJson.completion_tokens);
+				return {
+					prompt: promptTokens,
+					completion: completionTokens,
+					total: coerceStrToNum(responseJson.total_tokens) ?? (promptTokens !== void 0 && completionTokens !== void 0 ? promptTokens + completionTokens : void 0),
+					numRequests: 1
+				};
+			}
+			return missingBedrockTokenUsage();
+		}
+	},
+	MISTRAL_CHAT: BEDROCK_MISTRAL_CHAT_MODEL,
+	MISTRAL_LARGE_2407: BEDROCK_MISTRAL_CHAT_MODEL,
+	DEEPSEEK_CHAT: BEDROCK_DEEPSEEK_CHAT_MODEL,
+	OPENAI: {
+		params: async (config, prompt, stop, _modelName) => {
+			const params = { messages: require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_completion_tokens", config?.max_completion_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), .1);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(params, "reasoning_effort", config?.reasoning_effort);
+			if (stop && stop.length > 0 || config?.stop) addConfigParam(params, "stop", stop || config?.stop, require_logger.getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, require_logger.getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, require_logger.getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			return params;
+		},
+		output: (config, responseJson) => {
+			if (responseJson.error) throw new Error(`OpenAI API error: ${responseJson.error}`);
+			const content = responseJson.choices?.[0]?.message?.content;
+			const showThinking = config?.showThinking;
+			if (typeof content !== "string" || showThinking === void 0) return content;
+			const reasoningMatch = content.match(/^\s*<reasoning>([\s\S]*?)<\/reasoning>\s*([\s\S]*)$/);
+			if (!reasoningMatch) return content;
+			const [, reasoning, answer] = reasoningMatch;
+			if (showThinking) return `Thinking: ${reasoning.trim()}\n\n${answer}`;
+			return answer.trim() === "" ? content : answer;
+		},
+		tokenUsage: (responseJson, _promptText) => {
+			if (responseJson?.usage) {
+				const usage = responseJson.usage;
+				const reasoningTokens = coerceStrToNum(usage.completion_tokens_details?.reasoning_tokens);
+				const cachedInputTokens = coerceStrToNum(usage.prompt_tokens_details?.cached_tokens);
+				const completionDetails = {};
+				if (reasoningTokens !== void 0) completionDetails.reasoning = reasoningTokens;
+				if ((cachedInputTokens ?? 0) > 0) completionDetails.cacheReadInputTokens = cachedInputTokens;
+				return {
+					prompt: coerceStrToNum(usage.prompt_tokens),
+					completion: coerceStrToNum(usage.completion_tokens),
+					total: coerceStrToNum(usage.total_tokens),
+					numRequests: 1,
+					...Object.keys(completionDetails).length > 0 ? { completionDetails } : {}
+				};
+			}
+			return missingBedrockTokenUsage();
+		}
+	},
+	QWEN: {
+		params: async (config, prompt, stop, _modelName, vars) => {
+			const params = { messages: require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"), .7);
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			if (stop && stop.length > 0 || config?.stop) addConfigParam(params, "stop", stop || config?.stop, require_logger.getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, require_logger.getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, require_logger.getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			addConfigParam(params, "tools", await require_file.maybeLoadToolsFromExternalFile(config?.tools, vars), void 0, void 0);
+			addConfigParam(params, "tool_choice", config?.tool_choice, void 0, void 0);
+			return params;
+		},
+		output: (config, responseJson) => {
+			if (responseJson.error) throw new Error(`Qwen API error: ${responseJson.error}`);
+			if (responseJson.choices && Array.isArray(responseJson.choices)) {
+				const choice = responseJson.choices[0];
+				if (choice?.message?.tool_calls && Array.isArray(choice.message.tool_calls)) {
+					const toolCalls = choice.message.tool_calls.map((toolCall) => {
+						return `Called function ${toolCall.function.name} with arguments: ${toolCall.function.arguments}`;
+					}).join("\n");
+					if (choice.message.content) return `${choice.message.content}\n\n${toolCalls}`;
+					return toolCalls;
+				}
+				if (choice?.message?.content) {
+					const content = choice.message.content;
+					if (content.includes("<think>") && content.includes("</think>")) {
+						if (config.showThinking === false) {
+							const parts = content.split("</think>");
+							return parts.length > 1 ? parts[1].trim() : content;
+						}
+					}
+					return content;
+				}
+			}
+			return responseJson.choices?.[0]?.message?.content;
+		},
+		tokenUsage: getOpenAiCompatibleTokenUsage
+	},
+	/**
+	* Shared handler for newer Bedrock model families that speak the OpenAI Chat Completions
+	* wire format over InvokeModel: Z.AI (GLM), MiniMax, Moonshot (Kimi), NVIDIA (Nemotron),
+	* Google (Gemma), and Writer (Palmyra). Request body is `{ messages, max_tokens, ... }`
+	* and the response is `{ choices: [{ message: { content } }], usage }`.
+	*
+	* Differs from the gpt-oss `OPENAI` handler by sending `max_tokens` (not
+	* `max_completion_tokens`, which Writer Palmyra rejects) and by not forcing a
+	* `temperature`/`top_p` default, so each model uses its provider-recommended sampling
+	* defaults unless the user overrides them.
+	*/
+	OPENAI_COMPAT: {
+		params: async (config, prompt, stop, _modelName, vars) => {
+			const params = { messages: require_shared.parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS"));
+			addConfigParam(params, "temperature", config?.temperature, require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE"));
+			addConfigParam(params, "top_p", config?.top_p, require_logger.getEnvFloat("AWS_BEDROCK_TOP_P"));
+			const effectiveStop = config?.stop && config.stop.length > 0 ? config.stop : stop && stop.length > 0 ? stop : void 0;
+			if (effectiveStop) addConfigParam(params, "stop", effectiveStop);
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, require_logger.getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, require_logger.getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			addConfigParam(params, "reasoning_effort", config?.reasoning_effort);
+			addConfigParam(params, "tools", await require_file.maybeLoadToolsFromExternalFile(config?.tools, vars));
+			addConfigParam(params, "tool_choice", config?.tool_choice);
+			return params;
+		},
+		output: (config, responseJson) => {
+			if (responseJson.error) throw new Error(`Bedrock API error: ${responseJson.error}`);
+			const choice = responseJson.choices?.[0];
+			if (Array.isArray(choice?.message?.tool_calls) && choice.message.tool_calls.length > 0) {
+				const content = typeof choice.message.content === "string" && config?.showThinking === false ? choice.message.content.replace(/^\s*<(think|reasoning)>[\s\S]*?<\/\1>\s*/i, "") : choice.message.content;
+				const toolCalls = choice.message.tool_calls.map((toolCall) => `Called function ${toolCall.function?.name} with arguments: ${toolCall.function?.arguments}`).join("\n");
+				return content ? `${content}\n\n${toolCalls}` : toolCalls;
+			}
+			const content = choice?.message?.content;
+			if (typeof content !== "string") return content;
+			if (config.showThinking === false) {
+				const leadingBlock = content.match(/^\s*<(think|reasoning)>[\s\S]*?<\/\1>/);
+				if (leadingBlock) {
+					const stripped = content.slice(leadingBlock[0].length).trim();
+					return stripped === "" ? content : stripped;
+				}
+			}
+			return content;
+		},
+		tokenUsage: getOpenAiCompatibleTokenUsage
+	}
+};
+const AWS_BEDROCK_MODELS = {
+	"ai21.jamba-1-5-large-v1:0": BEDROCK_MODEL.AI21,
+	"ai21.jamba-1-5-mini-v1:0": BEDROCK_MODEL.AI21,
+	"amazon.nova-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"amazon.nova-micro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"amazon.nova-pro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"amazon.nova-premier-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"amazon.nova-2-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA_2,
+	"anthropic.claude-3-5-sonnet-20240620-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-3-5-sonnet-20241022-v2:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-3-7-sonnet-20250219-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-3-haiku-20240307-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-fable-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-fable-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-mythos-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-4-1-20250805-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-4-6-v1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-opus-4-5-20251101-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-sonnet-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-sonnet-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-sonnet-4-6": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-sonnet-4-5-20250929-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-haiku-4-5-20251001-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"anthropic.claude-sonnet-4-20250514-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"cohere.command-r-plus-v1:0": BEDROCK_MODEL.COHERE_COMMAND_R,
+	"cohere.command-r-v1:0": BEDROCK_MODEL.COHERE_COMMAND_R,
+	"deepseek.r1-v1:0": BEDROCK_MODEL.DEEPSEEK,
+	"deepseek.v3-v1:0": BEDROCK_MODEL.DEEPSEEK_CHAT,
+	"deepseek.v3.2": BEDROCK_MODEL.DEEPSEEK_CHAT,
+	"meta.llama3-1-405b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"meta.llama3-1-70b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"meta.llama3-1-8b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"meta.llama3-2-3b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"meta.llama3-3-70b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_3,
+	"meta.llama3-70b-instruct-v1:0": BEDROCK_MODEL.LLAMA3,
+	"meta.llama3-8b-instruct-v1:0": BEDROCK_MODEL.LLAMA3,
+	"meta.llama4-scout-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"meta.llama4-maverick-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"mistral.mistral-7b-instruct-v0:2": BEDROCK_MODEL.MISTRAL,
+	"mistral.devstral-2-123b": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.magistral-small-2509": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.ministral-3-14b-instruct": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.ministral-3-8b-instruct": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.ministral-3-3b-instruct": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.mistral-large-2402-v1:0": BEDROCK_MODEL.MISTRAL,
+	"mistral.mistral-large-2407-v1:0": BEDROCK_MODEL.MISTRAL_LARGE_2407,
+	"mistral.mistral-large-3-675b-instruct": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.mistral-small-2402-v1:0": BEDROCK_MODEL.MISTRAL,
+	"mistral.mixtral-8x7b-instruct-v0:1": BEDROCK_MODEL.MISTRAL,
+	"mistral.pixtral-large-2502-v1:0": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.voxtral-mini-3b-2507": BEDROCK_MODEL.MISTRAL_CHAT,
+	"mistral.voxtral-small-24b-2507": BEDROCK_MODEL.MISTRAL_CHAT,
+	"apac.amazon.nova-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"apac.amazon.nova-micro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"apac.amazon.nova-pro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"apac.amazon.nova-premier-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"apac.amazon.nova-2-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA_2,
+	"apac.anthropic.claude-3-5-sonnet-20240620-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-3-haiku-20240307-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-opus-4-1-20250805-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-opus-4-6-v1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-opus-4-5-20251101-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-sonnet-4-6": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-sonnet-4-5-20250929-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-haiku-4-5-20251001-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.anthropic.claude-sonnet-4-20250514-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"apac.meta.llama4-scout-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"apac.meta.llama4-maverick-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"au.anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"au.anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"au.anthropic.claude-opus-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"au.anthropic.claude-sonnet-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.amazon.nova-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"eu.amazon.nova-micro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"eu.amazon.nova-pro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"eu.amazon.nova-premier-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"eu.amazon.nova-2-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA_2,
+	"eu.anthropic.claude-3-5-sonnet-20240620-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-3-7-sonnet-20250219-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-3-haiku-20240307-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-4-1-20250805-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-4-6-v1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-opus-4-5-20251101-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-sonnet-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-sonnet-4-6": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-sonnet-4-5-20250929-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-haiku-4-5-20251001-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.anthropic.claude-sonnet-4-20250514-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"eu.meta.llama3-2-1b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"eu.meta.llama3-2-3b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"eu.meta.llama4-scout-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"eu.meta.llama4-maverick-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"eu.mistral.pixtral-large-2502-v1:0": BEDROCK_MODEL.MISTRAL_CHAT,
+	"us-gov.anthropic.claude-3-5-sonnet-20240620-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us-gov.anthropic.claude-3-haiku-20240307-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.amazon.nova-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"us.amazon.nova-micro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"us.amazon.nova-pro-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"us.amazon.nova-premier-v1:0": BEDROCK_MODEL.AMAZON_NOVA,
+	"us.amazon.nova-2-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA_2,
+	"us.anthropic.claude-3-5-sonnet-20240620-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-3-5-sonnet-20241022-v2:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-3-7-sonnet-20250219-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-3-haiku-20240307-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-fable-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-fable-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-mythos-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-4-1-20250805-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-4-6-v1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-opus-4-5-20251101-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-sonnet-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-sonnet-4-6": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-sonnet-4-5-20250929-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-haiku-4-5-20251001-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.anthropic.claude-sonnet-4-20250514-v1:0": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"us.deepseek.r1-v1:0": BEDROCK_MODEL.DEEPSEEK,
+	"us.meta.llama3-1-405b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"us.meta.llama3-1-70b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"us.meta.llama3-1-8b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_1,
+	"us.meta.llama3-2-11b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"us.meta.llama3-2-1b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"us.meta.llama3-2-3b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"us.meta.llama3-2-90b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_2,
+	"us.meta.llama3-3-70b-instruct-v1:0": BEDROCK_MODEL.LLAMA3_3,
+	"us.meta.llama4-scout-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"us.meta.llama4-maverick-17b-instruct-v1:0": BEDROCK_MODEL.LLAMA4,
+	"us.mistral.pixtral-large-2502-v1:0": BEDROCK_MODEL.MISTRAL_CHAT,
+	"openai.gpt-oss-120b-1:0": BEDROCK_MODEL.OPENAI,
+	"openai.gpt-oss-20b-1:0": BEDROCK_MODEL.OPENAI,
+	"openai.gpt-oss-safeguard-120b": BEDROCK_MODEL.OPENAI,
+	"openai.gpt-oss-safeguard-20b": BEDROCK_MODEL.OPENAI,
+	"us.xai.grok-4.6": BEDROCK_MODEL.OPENAI_COMPAT,
+	"global.xai.grok-4.6": BEDROCK_MODEL.OPENAI_COMPAT,
+	"qwen.qwen3-coder-next": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-coder-480b-a35b-v1:0": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-coder-30b-a3b-v1:0": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-next-80b-a3b": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-vl-235b-a22b": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-235b-a22b-2507-v1:0": BEDROCK_MODEL.QWEN,
+	"qwen.qwen3-32b-v1:0": BEDROCK_MODEL.QWEN,
+	"zai.glm-5": BEDROCK_MODEL.OPENAI_COMPAT,
+	"zai.glm-4.7": BEDROCK_MODEL.OPENAI_COMPAT,
+	"zai.glm-4.7-flash": BEDROCK_MODEL.OPENAI_COMPAT,
+	"minimax.minimax-m2": BEDROCK_MODEL.OPENAI_COMPAT,
+	"minimax.minimax-m2.1": BEDROCK_MODEL.OPENAI_COMPAT,
+	"minimax.minimax-m2.5": BEDROCK_MODEL.OPENAI_COMPAT,
+	"moonshotai.kimi-k2.5": BEDROCK_MODEL.OPENAI_COMPAT,
+	"moonshot.kimi-k2-thinking": BEDROCK_MODEL.OPENAI_COMPAT,
+	"nvidia.nemotron-nano-9b-v2": BEDROCK_MODEL.OPENAI_COMPAT,
+	"nvidia.nemotron-nano-12b-v2": BEDROCK_MODEL.OPENAI_COMPAT,
+	"nvidia.nemotron-nano-3-30b": BEDROCK_MODEL.OPENAI_COMPAT,
+	"nvidia.nemotron-super-3-120b": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us-gov.nvidia.nemotron-nano-9b-v2": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us-gov.nvidia.nemotron-nano-12b-v2": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us-gov.nvidia.nemotron-nano-3-30b": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us-gov.nvidia.nemotron-super-3-120b": BEDROCK_MODEL.OPENAI_COMPAT,
+	"google.gemma-3-4b-it": BEDROCK_MODEL.OPENAI_COMPAT,
+	"google.gemma-3-12b-it": BEDROCK_MODEL.OPENAI_COMPAT,
+	"google.gemma-3-27b-it": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us.writer.palmyra-x5-v1:0": BEDROCK_MODEL.OPENAI_COMPAT,
+	"us.writer.palmyra-x4-v1:0": BEDROCK_MODEL.OPENAI_COMPAT,
+	"writer.palmyra-vision-7b": BEDROCK_MODEL.OPENAI_COMPAT,
+	"global.amazon.nova-2-lite-v1:0": BEDROCK_MODEL.AMAZON_NOVA_2,
+	"global.anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"jp.anthropic.claude-opus-4-7": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"jp.anthropic.claude-opus-4-8": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-opus-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"jp.anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"au.anthropic.claude-opus-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-fable-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-fable-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-mythos-5-1": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-sonnet-5": BEDROCK_MODEL.CLAUDE_MESSAGES,
+	"global.anthropic.claude-sonnet-5-5": BEDROCK_MODEL.CLAUDE_MESSAGES
+};
+function getCanonicalMessagesOnlyModel(modelName) {
+	const mythosMatch = /^(?:[^.]+\.)?(anthropic\.claude-mythos-(?:5|preview))$/.exec(modelName);
+	if (mythosMatch) return mythosMatch[1];
+	if (require_routing.requiresBedrockAnthropicMessagesModel(modelName)) return modelName;
+}
+/**
+* Model IDs AWS no longer serves. Kept so a config pinned to one fails with a clear local
+* error instead of reaching the `anthropic.claude` catch-all below (or, on the Converse
+* route, the remote API) and failing with something less obvious.
+*
+* The Claude entries were verified absent from `list-foundation-models` in all 17 commercial
+* regions on 2026-09-04. Note this is Bedrock's lifecycle, not Anthropic's: several models
+* retired on the Anthropic API are still served here and must NOT be listed.
+*
+* Use bare IDs; the availability check removes inference-profile prefixes.
+*/
+const RETIRED_BEDROCK_MODELS = /* @__PURE__ */ new Set([
+	"anthropic.claude-3-opus-20240229-v1:0",
+	"anthropic.claude-opus-4-20250514-v1:0",
+	"anthropic.claude-3-5-haiku-20241022-v1:0",
+	"anthropic.claude-instant-v1",
+	"anthropic.claude-v1",
+	"anthropic.claude-v2",
+	"anthropic.claude-v2:1",
+	"cohere.command-text-v14",
+	"cohere.command-light-text-v14",
+	"meta.llama2-13b-chat-v1",
+	"meta.llama2-70b-chat-v1"
+]);
+/** Reject withdrawn models before InvokeModel, Converse, or Knowledge Base requests. */
+function assertBedrockModelIsAvailable(modelName) {
+	const modelId = modelName.startsWith("arn:") ? /:(?:inference-profile|foundation-model)\/([^/]+)$/.exec(modelName)?.[1] ?? modelName : modelName;
+	if (RETIRED_BEDROCK_MODELS.has(modelId.replace(require_base.INFERENCE_PROFILE_PREFIX, ""))) throw new Error(`Unknown Amazon Bedrock model: ${modelName}`);
+}
+function getHandlerForModel(modelName, config) {
+	assertBedrockModelIsAvailable(modelName);
+	const messagesOnlyModel = getCanonicalMessagesOnlyModel(modelName);
+	if (messagesOnlyModel) throw new Error(`Amazon Bedrock model "${modelName}" uses Bedrock's Anthropic Messages API, not InvokeModel. Load it as "bedrock:${messagesOnlyModel}" instead.`);
+	if (modelName.includes("arn:") && modelName.includes("inference-profile")) {
+		const inferenceModelType = config?.inferenceModelType;
+		if (!inferenceModelType) throw new Error("Inference profile requires inferenceModelType to be specified in config. Options: claude, nova, nova2, llama (defaults to v4), llama2, llama3, llama3.1, llama3.2, llama3.3, llama4, mistral, cohere, ai21, titan, deepseek, openai, qwen, zai, minimax, moonshot, nvidia, writer, gemma");
+		switch (inferenceModelType) {
+			case "claude": return BEDROCK_MODEL.CLAUDE_MESSAGES;
+			case "nova": return BEDROCK_MODEL.AMAZON_NOVA;
+			case "llama": return BEDROCK_MODEL.LLAMA4;
+			case "llama2": return BEDROCK_MODEL.LLAMA2;
+			case "llama3": return BEDROCK_MODEL.LLAMA3;
+			case "llama3.1":
+			case "llama3_1": return BEDROCK_MODEL.LLAMA3_1;
+			case "llama3.2":
+			case "llama3_2": return BEDROCK_MODEL.LLAMA3_2;
+			case "llama3.3":
+			case "llama3_3": return BEDROCK_MODEL.LLAMA3_3;
+			case "llama4": return BEDROCK_MODEL.LLAMA4;
+			case "mistral": return BEDROCK_MODEL.MISTRAL;
+			case "cohere": return BEDROCK_MODEL.COHERE_COMMAND_R;
+			case "ai21": return BEDROCK_MODEL.AI21;
+			case "titan": return BEDROCK_MODEL.TITAN_TEXT;
+			case "deepseek": return BEDROCK_MODEL.DEEPSEEK;
+			case "openai": return BEDROCK_MODEL.OPENAI;
+			case "qwen": return BEDROCK_MODEL.QWEN;
+			case "nova2": return BEDROCK_MODEL.AMAZON_NOVA_2;
+			case "zai":
+			case "minimax":
+			case "moonshot":
+			case "nvidia":
+			case "writer":
+			case "gemma": return BEDROCK_MODEL.OPENAI_COMPAT;
+			default: throw new Error(`Unknown inference model type: ${inferenceModelType}`);
+		}
+	}
+	const ret = AWS_BEDROCK_MODELS[modelName];
+	if (ret) return ret;
+	if (modelName.startsWith("ai21.")) return BEDROCK_MODEL.AI21;
+	if (modelName.includes("amazon.nova-2")) return BEDROCK_MODEL.AMAZON_NOVA_2;
+	if (modelName.includes("amazon.nova")) return BEDROCK_MODEL.AMAZON_NOVA;
+	if (modelName.includes("anthropic.claude")) return BEDROCK_MODEL.CLAUDE_MESSAGES;
+	if (modelName.startsWith("meta.llama2")) return BEDROCK_MODEL.LLAMA2;
+	if (modelName.includes("meta.llama3-1")) return BEDROCK_MODEL.LLAMA3_1;
+	if (modelName.includes("meta.llama3-2")) return BEDROCK_MODEL.LLAMA3_2;
+	if (modelName.includes("meta.llama3-3")) return BEDROCK_MODEL.LLAMA3_3;
+	if (modelName.includes("meta.llama4")) return BEDROCK_MODEL.LLAMA4;
+	if (modelName.includes("meta.llama3")) return BEDROCK_MODEL.LLAMA3;
+	if (modelName.startsWith("cohere.command-r")) return BEDROCK_MODEL.COHERE_COMMAND_R;
+	if (modelName.startsWith("cohere.command")) return BEDROCK_MODEL.COHERE_COMMAND;
+	if (modelName.startsWith("mistral.")) return BEDROCK_MODEL.MISTRAL;
+	if (modelName.startsWith("deepseek.")) return BEDROCK_MODEL.DEEPSEEK;
+	if (modelName.startsWith("qwen.")) return BEDROCK_MODEL.QWEN;
+	if (modelName.includes("openai.gpt-oss")) {
+		if (/-\d+:\d+$/.test(modelName)) return BEDROCK_MODEL.OPENAI;
+		throw new Error(`Amazon Bedrock model "${modelName}" looks like the Bedrock Mantle id for an open-weight gpt-oss model. promptfoo's bedrock: provider calls the InvokeModel (bedrock-runtime) API, which uses the versioned runtime id — e.g. "bedrock:openai.gpt-oss-120b-1:0". See https://www.promptfoo.dev/docs/providers/aws-bedrock/#openai-models`);
+	}
+	if (modelName.includes("openai.")) {
+		const bareFrontierId = modelName.replace(/^[a-z]+\.(?=openai\.)/, "");
+		if (/^[a-z]+\.openai\.gpt-5\.6-(?:sol|terra|luna)$/.test(modelName)) throw new Error(`OpenAI model "${modelName}" is not served by Bedrock's InvokeModel API. For a supported Runtime inference profile, use "bedrock:converse:${modelName}" with AWS credentials, or "bedrock:${bareFrontierId}" with AWS_BEARER_TOKEN_BEDROCK for Mantle Responses.`);
+		throw new Error(`OpenAI model "${modelName}" is not served by Bedrock's InvokeModel API. Frontier models (gpt-5.x) use the OpenAI-compatible Responses API — use "bedrock:${bareFrontierId}" and set AWS_BEARER_TOKEN_BEDROCK. See https://www.promptfoo.dev/docs/providers/aws-bedrock/#openai-models`);
+	}
+	if (modelName.includes("xai.") || modelName.includes("grok")) throw new Error(`xAI model "${modelName}" is not served by Bedrock's InvokeModel API under that id. Grok 4.6 supports Runtime Converse through an inference profile — use "bedrock:converse:us.xai.grok-4.6" or "bedrock:converse:global.xai.grok-4.6" with ordinary AWS credentials. Other Grok models run on the OpenAI-compatible Responses API (mantle endpoint) — use the bare id such as "bedrock:xai.grok-4.3" and set AWS_BEARER_TOKEN_BEDROCK. See https://www.promptfoo.dev/docs/providers/aws-bedrock/#xai-grok-models`);
+	throw new Error(`Unknown Amazon Bedrock model: ${modelName}`);
+}
+var AwsBedrockCompletionProvider = class extends require_base.AwsBedrockGenericProvider {
+	static AWS_BEDROCK_COMPLETION_MODELS = Object.keys(AWS_BEDROCK_MODELS);
+	async callApi(prompt, context) {
+		let stop;
+		try {
+			stop = require_logger.getEnvString("AWS_BEDROCK_STOP") ? JSON.parse(require_logger.getEnvString("AWS_BEDROCK_STOP")) : [];
+		} catch (err) {
+			throw new Error(`BEDROCK_STOP is not a valid JSON string: ${err}`);
+		}
+		const mergedConfig = {
+			...this.config,
+			...context?.prompt.config
+		};
+		let model = getHandlerForModel(this.modelName, mergedConfig);
+		if (!model) {
+			require_logger.logger.warn(`Unknown Amazon Bedrock model: ${this.modelName}. Assuming its API is Claude-like.`);
+			model = BEDROCK_MODEL.CLAUDE_MESSAGES;
+		}
+		const params = await model.params(mergedConfig, prompt, stop, this.modelName, context?.vars);
+		require_logger.logger.debug("Calling Amazon Bedrock API", { params });
+		const cache = await require_cache.getCache();
+		const region = this.getRegion();
+		const cacheKey = `bedrock:${this.modelName}:${region}:${require_base.createBedrockCacheKeyHash({
+			config: this.config,
+			params,
+			region
+		})}`;
+		if (require_cache.isCacheEnabled()) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				require_logger.logger.debug(`Returning cached response for ${prompt}: ${cachedResponse}`);
+				return {
+					output: model.output(mergedConfig, JSON.parse(cachedResponse)),
+					tokenUsage: require_tokenUsageUtils.createEmptyTokenUsage(),
+					cached: true
+				};
+			}
+		}
+		let response;
+		try {
+			const bedrockInstance = await this.getBedrockInstance();
+			try {
+				const testCredentials = await bedrockInstance.config.credentials?.();
+				require_logger.logger.debug(`Actual credentials being used: ${testCredentials?.accessKeyId ? `accessKeyId starts with: ${testCredentials.accessKeyId.substring(0, 4)}...` : "no explicit credentials (using instance metadata)"}`);
+			} catch (credErr) {
+				require_logger.logger.debug(`Error getting credentials: ${credErr}`);
+			}
+			response = await bedrockInstance.invokeModel({
+				modelId: this.modelName,
+				...this.config.guardrailIdentifier ? { guardrailIdentifier: String(this.config.guardrailIdentifier) } : {},
+				...this.config.guardrailVersion ? { guardrailVersion: String(this.config.guardrailVersion) } : {},
+				...this.config.trace ? { trace: this.config.trace } : {},
+				accept: "application/json",
+				contentType: "application/json",
+				body: JSON.stringify(params)
+			});
+		} catch (err) {
+			return { error: `Bedrock API invoke model error: ${String(err)}` };
+		}
+		require_logger.logger.debug(`Amazon Bedrock API response: ${response.body.transformToString()}`);
+		if (require_cache.isCacheEnabled()) try {
+			await cache.set(cacheKey, new TextDecoder().decode(response.body));
+		} catch (err) {
+			require_logger.logger.error(`Failed to cache response: ${String(err)}`);
+		}
+		try {
+			const output = JSON.parse(new TextDecoder().decode(response.body));
+			let tokenUsage = {};
+			if (model.tokenUsage) {
+				tokenUsage = model.tokenUsage(output, prompt);
+				require_logger.logger.debug(`Token usage from model handler: ${JSON.stringify(tokenUsage)}`);
+			} else {
+				const promptTokens = output.usage?.inputTokens ?? output.usage?.input_tokens ?? output.usage?.prompt_tokens ?? output.prompt_tokens ?? output.prompt_token_count;
+				const completionTokens = output.usage?.outputTokens ?? output.usage?.output_tokens ?? output.usage?.completion_tokens ?? output.completion_tokens ?? output.generation_token_count;
+				const promptTokensNum = coerceStrToNum(promptTokens);
+				const completionTokensNum = coerceStrToNum(completionTokens);
+				tokenUsage = {
+					prompt: promptTokensNum,
+					completion: completionTokensNum,
+					total: coerceStrToNum(output.usage?.totalTokens ?? output.usage?.total_tokens ?? output.total_tokens) ?? (promptTokensNum !== void 0 && completionTokensNum !== void 0 ? promptTokensNum + completionTokensNum : void 0),
+					numRequests: 1
+				};
+				if (tokenUsage.prompt === void 0 && tokenUsage.completion === void 0 && tokenUsage.total === void 0 && output) require_logger.logger.debug(`No explicit token counts found for ${this.modelName}, tracking request count only`);
+				else require_logger.logger.debug(`Extracted token usage: ${JSON.stringify(tokenUsage)}`);
+			}
+			if (!tokenUsage.numRequests) tokenUsage.numRequests = 1;
+			const cacheReadInputTokens = tokenUsage.completionDetails?.cacheReadInputTokens ?? (require_pricing.isBedrockGrok46Profile(this.modelName) ? coerceStrToNum(output.usage?.prompt_tokens_details?.cached_tokens) : coerceStrToNum(output.usage?.cache_read_input_tokens));
+			const billablePromptTokens = model === BEDROCK_MODEL.CLAUDE_MESSAGES ? coerceStrToNum(output.usage?.input_tokens ?? output.usage?.prompt_tokens) : require_pricing.isBedrockGrok46Profile(this.modelName) && tokenUsage.prompt !== void 0 ? Math.max(tokenUsage.prompt - (cacheReadInputTokens ?? 0), 0) : tokenUsage.prompt;
+			const cost = require_pricing.calculateBedrockInvokeModelCost(this.modelName, billablePromptTokens, tokenUsage.completion, cacheReadInputTokens, tokenUsage.completionDetails?.cacheCreationInputTokens ?? coerceStrToNum(output.usage?.cache_creation_input_tokens), region, coerceStrToNum(output.usage?.cache_creation?.ephemeral_1h_input_tokens));
+			return {
+				output: model.output(mergedConfig, output),
+				tokenUsage,
+				cost,
+				...output["amazon-bedrock-guardrailAction"] ? { guardrails: { flagged: output["amazon-bedrock-guardrailAction"] === "INTERVENED" } } : {}
+			};
+		} catch (err) {
+			require_logger.logger.error("Bedrock API response error", {
+				error: String(err),
+				response
+			});
+			return { error: `API response error: ${String(err)}: ${JSON.stringify(response)}` };
+		}
+	}
+};
+var AwsBedrockEmbeddingProvider = class extends require_base.AwsBedrockGenericProvider {
+	supportsEmbeddingCancellation = true;
+	constructor(modelName, options = {}) {
+		super(modelName, options);
+	}
+	async callApi() {
+		throw new Error("callApi is not implemented for embedding provider");
+	}
+	async callEmbeddingApi(text, _context, options) {
+		const params = this.modelName.includes("cohere.embed") ? {
+			texts: [text],
+			input_type: this.config.input_type ?? "search_document"
+		} : { inputText: text };
+		require_logger.logger.debug("Calling AWS Bedrock API for embeddings", { params });
+		let response;
+		try {
+			const bedrockInstance = await this.getBedrockInstance();
+			const command = {
+				modelId: this.modelName,
+				accept: "application/json",
+				contentType: "application/json",
+				body: JSON.stringify(params)
+			};
+			response = options?.abortSignal ? await bedrockInstance.invokeModel(command, { abortSignal: options.abortSignal }) : await bedrockInstance.invokeModel(command);
+		} catch (err) {
+			options?.abortSignal?.throwIfAborted();
+			return { error: `API call error: ${String(err)}` };
+		}
+		require_logger.logger.debug(`AWS Bedrock API response (embeddings): ${JSON.stringify(response.body.transformToString())}`);
+		try {
+			const data = JSON.parse(response.body.transformToString());
+			const embeddings = data?.embeddings?.float ?? data?.embeddings;
+			const embedding = data?.embedding ?? (Array.isArray(embeddings) && embeddings.length === 1 ? embeddings[0] : void 0);
+			if (!Array.isArray(embedding) || embedding.length === 0 || !embedding.every((value) => typeof value === "number" && Number.isFinite(value))) throw new Error("No valid embedding found in AWS Bedrock API response");
+			return { embedding };
+		} catch (err) {
+			return { error: `API response error: ${String(err)}: ${JSON.stringify(response.body.transformToString())}` };
+		}
+	}
+};
+//#endregion
+//#region src/providers/bedrock/converse.ts
+/**
+* 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
+*/
+function getOneHourCacheWriteTokens(cacheDetails) {
+	return cacheDetails?.reduce((total, detail) => total + (detail.ttl === "1h" ? detail.inputTokens ?? 0 : 0), 0) ?? 0;
+}
+/**
+* Convert various tool formats to Converse API format.
+* Supports OpenAI, Anthropic, and native Bedrock formats.
+*/
+function convertToolsToConverseFormat(tools) {
+	if (require_shared.isOpenAIToolArray(tools)) return require_shared.openaiToolsToBedrock(tools);
+	return tools.map((tool) => {
+		if (tool.toolSpec) return { toolSpec: tool.toolSpec };
+		if (tool.type === "function" && tool.function) return { toolSpec: {
+			name: tool.function.name,
+			description: tool.function.description,
+			inputSchema: { json: tool.function.parameters || {} }
+		} };
+		if (tool.name && "parameters" in tool && !("input_schema" in tool)) return { toolSpec: {
+			name: tool.name,
+			description: tool.description,
+			inputSchema: { json: tool.parameters || {
+				type: "object",
+				properties: {}
+			} }
+		} };
+		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)}`);
+	});
+}
+function transformMCPToolsToBedrockConverse(tools) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const tool of tools) {
+		if (seen.has(tool.name)) {
+			require_logger.logger.warn(`[Bedrock Converse] Duplicate MCP tool name '${tool.name}' detected; using the first server's definition.`);
+			continue;
+		}
+		seen.add(tool.name);
+		const { $schema: _$schema, ...cleanSchema } = tool.inputSchema || {};
+		result.push({ toolSpec: {
+			name: tool.name,
+			description: tool.description,
+			inputSchema: { json: {
+				type: "object",
+				...cleanSchema
+			} }
+		} });
+	}
+	return result;
+}
+/**
+* Extract a printable message from an unknown thrown value without losing
+* non-`Error` payloads to `[object Object]`.
+*/
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Coerces a tool_use input value into a plain object suitable for `MCPClient.callTool`.
+* Total: never throws. Malformed JSON strings yield `{}` so an MCP call still happens with
+* empty args rather than crashing the whole eval row.
+*/
+function parseToolInput(input) {
+	if (typeof input === "string") {
+		if (!input) return {};
+		try {
+			const parsed = JSON.parse(input);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch (err) {
+			require_logger.logger.warn(`[Bedrock Converse] Failed to parse tool_use input as JSON: ${err}`);
+			return {};
+		}
+	}
+	return input && typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+/**
+* True when an MCP server config has at least one transport (command+args, path, or url).
+* Empty strings count as unset.
+*/
+function isMCPServerConfigured(server) {
+	if (!server) return false;
+	return Boolean(server.command || server.path || server.url);
+}
+function hasUsableMCPServer(mcp) {
+	if (!mcp) return false;
+	if (mcp.server && isMCPServerConfigured(mcp.server)) return true;
+	return Boolean(mcp.servers?.some(isMCPServerConfigured));
+}
+function joinMcpErrors(errors) {
+	return errors.length > 0 ? errors.join("; ") : void 0;
+}
+function formatMcpToolResult(name, content) {
+	return `MCP Tool Result (${name}): ${require_util.normalizeMcpToolContent(content, (part) => {
+		require_logger.logger.debug("[Bedrock Converse] Unknown MCP content shape, serializing as JSON", { keys: Object.keys(part) });
+	})}`;
+}
+function formatMcpToolError(name, message) {
+	return `MCP Tool Error (${name}): ${message}`;
+}
+/**
+* Parses streaming tool_use input that arrived as concatenated JSON deltas.
+* Always returns a plain object (the only shape `MCPClient.callTool` accepts);
+* `failed` is `true` when the raw text was non-empty but not valid JSON, so
+* callers can surface the parse error rather than silently calling MCP with
+* `{}`.
+*/
+function parseStreamingToolInput(raw) {
+	if (!raw) return {
+		value: {},
+		failed: false
+	};
+	try {
+		return {
+			value: parseToolInput(JSON.parse(raw)),
+			failed: false
+		};
+	} catch (err) {
+		require_logger.logger.warn(`[Bedrock Converse] Streaming tool_use input was not valid JSON: ${errorMessage(err)}`);
+		return {
+			value: {},
+			failed: true
+		};
+	}
+}
+/**
+* Convert tool choice to Converse API format.
+* Supports OpenAI tool choice format and native Bedrock format.
+*/
+function isNamedConverseToolChoice(toolChoice) {
+	if (!toolChoice || typeof toolChoice !== "object" || !("tool" in toolChoice)) return false;
+	const tool = toolChoice.tool;
+	return Boolean(tool && typeof tool === "object" && typeof tool.name === "string");
+}
+function convertToolChoiceToConverseFormat(toolChoice) {
+	if (require_shared.isOpenAIToolChoice(toolChoice)) return require_shared.openaiToolChoiceToBedrock(toolChoice);
+	if (toolChoice === "any") return { any: {} };
+	if (isNamedConverseToolChoice(toolChoice)) return { tool: { name: toolChoice.tool.name } };
+	return { auto: {} };
+}
+function isDisabledToolChoice(toolChoice) {
+	return toolChoice === "none";
+}
+/**
+* Parse prompt into Converse API message format
+*/
+function parseConverseMessages(prompt) {
+	try {
+		const parsed = JSON.parse(prompt);
+		if (Array.isArray(parsed)) {
+			const systemMessages = [];
+			const messages = [];
+			for (const msg of parsed) if (msg.role === "system") {
+				const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+				systemMessages.push({ text: content });
+			} else if (msg.role === "user" || msg.role === "assistant") {
+				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) {
+					const imageData = block.image || block;
+					let bytes;
+					let format = "png";
+					if (imageData.format) format = imageData.format;
+					else if (imageData.source?.media_type) format = imageData.source.media_type.split("/")[1] || "png";
+					if (imageData.source?.bytes) {
+						const rawBytes = imageData.source.bytes;
+						if (typeof rawBytes === "string") {
+							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 bytes = Buffer.from(rawBytes, "base64");
+						} else if (Buffer.isBuffer(rawBytes)) bytes = rawBytes;
+					} else if (imageData.source?.data) bytes = Buffer.from(imageData.source.data, "base64");
+					if (bytes) {
+						if (format === "jpg") format = "jpeg";
+						contentBlocks.push({ image: {
+							format,
+							source: { bytes }
+						} });
+					} else require_logger.logger.warn("Could not parse image content block", { block });
+				} else if (block.type === "image_url" || block.image_url) {
+					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,
+								source: { bytes }
+							} });
+						}
+					} else require_logger.logger.warn("Unsupported image_url format (only data URLs supported)", { imageUrl });
+				} else if (block.type === "document" || block.document) {
+					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") {
+							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,
+						name,
+						source: { bytes }
+					} });
+					else require_logger.logger.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 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 : void 0
+			};
+		}
+	} catch {}
+	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 {
+			currentRole = "user";
+			currentContent.push(line);
+		}
+	}
+	pushMessage();
+	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) {
+		const reasoning = block.reasoningContent;
+		if (showThinking) {
+			if ("reasoningText" in reasoning && reasoning.reasoningText) {
+				const thinkingText = reasoning.reasoningText.text || "";
+				const signature = reasoning.reasoningText.signature || "";
+				if (thinkingText.trim() !== "") {
+					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) 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
+*/
+var AwsBedrockConverseProvider = class extends require_base.AwsBedrockGenericProvider {
+	mcpClient = null;
+	initializationPromise = null;
+	mcpInitError = null;
+	registeredForShutdown = false;
+	loadedFunctionCallbacks = {};
+	forcedToolChoiceRemovalWarned = false;
+	constructor(modelName, options = {}) {
+		super(modelName, options);
+		this.config = options.config || {};
+		if (this.config.thinking) require_telemetry.telemetry.record("feature_used", {
+			feature: "extended_thinking",
+			provider: "bedrock_converse"
+		});
+		if (this.config.reasoningConfig?.type === "enabled") require_telemetry.telemetry.record("feature_used", {
+			feature: "nova2_reasoning",
+			provider: "bedrock_converse"
+		});
+		if (this.config.tools) require_telemetry.telemetry.record("feature_used", {
+			feature: "tool_use",
+			provider: "bedrock_converse"
+		});
+		if (this.config.mcp?.enabled && hasUsableMCPServer(this.config.mcp)) this.initializationPromise = this.initializeMCP().catch((err) => {
+			this.mcpInitError = err instanceof Error ? err : new Error(String(err));
+			require_logger.logger.error(`[Bedrock Converse] MCP initialization failed: ${this.mcpInitError.message}`);
+		});
+	}
+	id() {
+		return `bedrock:converse:${this.modelName}`;
+	}
+	toString() {
+		return `[AWS Bedrock Converse Provider ${this.modelName}]`;
+	}
+	async initializeMCP() {
+		if (!this.config.mcp) return;
+		this.mcpClient = new require_client.MCPClient(this.config.mcp);
+		if (!this.registeredForShutdown) {
+			require_providerRegistry.providerRegistry.register(this);
+			this.registeredForShutdown = true;
+		}
+		await this.mcpClient.initialize();
+	}
+	/**
+	* Called by `providerRegistry.shutdownAll()` from the evaluator. Delegates
+	* to `cleanup()` so external callers can use either name.
+	*/
+	async shutdown() {
+		await this.cleanup();
+	}
+	/**
+	* Releases the MCP client and any spawned transport (e.g. stdio child
+	* processes). Safe to call multiple times and resilient to a failed init —
+	* partially-initialized state is still attempted to be torn down so we don't
+	* leak resources.
+	*/
+	async cleanup() {
+		if (!this.mcpClient && this.initializationPromise == null) return;
+		if (this.initializationPromise != null) try {
+			await this.initializationPromise;
+		} catch (err) {
+			require_logger.logger.warn(`[Bedrock Converse] MCP init had failed; cleaning up anyway: ${errorMessage(err)}`);
+		}
+		if (this.mcpClient) {
+			try {
+				await this.mcpClient.cleanup();
+			} catch (err) {
+				require_logger.logger.error(`[Bedrock Converse] MCP client cleanup failed: ${errorMessage(err)}`);
+			}
+			this.mcpClient = null;
+		}
+		this.initializationPromise = null;
+		if (this.registeredForShutdown) {
+			require_providerRegistry.providerRegistry.unregister(this);
+			this.registeredForShutdown = false;
+		}
+	}
+	/**
+	* 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) {
+		return require_functionCallbackUtils.loadProviderCallbackFromFileUrl(fileRef, "[Bedrock Converse]");
+	}
+	/**
+	* Executes a function callback with proper error handling
+	*/
+	async executeFunctionCallback(functionName, args, callId) {
+		return require_functionCallbackUtils.executeProviderFunctionCallback({
+			functionName,
+			args,
+			callId,
+			callbacks: this.config.functionToolCallbacks,
+			cache: this.loadedFunctionCallbacks,
+			logPrefix: "[Bedrock Converse]"
+		});
+	}
+	/**
+	* Build the inference configuration from options
+	*
+	* Handles Amazon Nova 2 reasoning constraints:
+	* - When reasoningConfig.type === 'enabled': temperature/topP must NOT be set
+	* - When maxReasoningEffort === 'high': maxTokens must also NOT be set
+	*/
+	buildInferenceConfig() {
+		const reasoningEnabled = this.config.reasoningConfig?.type === "enabled";
+		const isHighEffort = this.config.reasoningConfig?.maxReasoningEffort === "high";
+		const maxTokensValue = this.config.maxTokens ?? this.config.max_tokens ?? require_logger.getEnvInt("AWS_BEDROCK_MAX_TOKENS") ?? void 0;
+		const temperatureValue = this.config.temperature ?? require_logger.getEnvFloat("AWS_BEDROCK_TEMPERATURE") ?? void 0;
+		const topPValue = this.config.topP ?? this.config.top_p ?? require_logger.getEnvFloat("AWS_BEDROCK_TOP_P");
+		let stopSequences = this.config.stopSequences || this.config.stop;
+		if (!stopSequences) {
+			const envStop = require_logger.getEnvString("AWS_BEDROCK_STOP");
+			if (envStop) try {
+				stopSequences = JSON.parse(envStop);
+			} catch {}
+		}
+		const maxTokens = reasoningEnabled && isHighEffort ? void 0 : maxTokensValue;
+		const samplingParamsDeprecated = require_util$1.isSamplingParamsDeprecatedClaudeModel(this.modelName);
+		let temperature = reasoningEnabled || samplingParamsDeprecated ? void 0 : temperatureValue;
+		let topP = reasoningEnabled || samplingParamsDeprecated ? void 0 : topPValue;
+		if (this.modelName.includes("anthropic.claude")) {
+			const rawThinking = this.config.additionalModelRequestFields?.thinking;
+			const { sampling, warnings } = require_util$1.resolveClaudeSamplingParams({
+				temperature,
+				top_p: topP
+			}, {
+				thinkingEnabled: require_util$1.isClaudeThinkingEnabled(this.config.thinking ?? rawThinking),
+				samplingParamsDeprecated
+			});
+			for (const warning of warnings) require_logger.logger.warn(warning);
+			temperature = sampling.temperature;
+			topP = sampling.top_p;
+		}
+		if (maxTokens !== void 0 || temperature !== void 0 || topP !== void 0 || stopSequences) return {
+			...maxTokens === void 0 ? {} : { maxTokens },
+			...temperature === void 0 ? {} : { temperature },
+			...topP === void 0 ? {} : { topP },
+			...stopSequences ? { stopSequences } : {}
+		};
+	}
+	/**
+	* Build the tool configuration from options
+	* Merges prompt.config with provider config, with prompt.config taking precedence
+	*/
+	async buildToolConfig(vars, promptConfig) {
+		const configToolChoice = this.getEffectiveToolChoice(promptConfig);
+		if (isDisabledToolChoice(configToolChoice)) return;
+		const mcpTools = this.mcpClient ? transformMCPToolsToBedrockConverse(this.mcpClient.getAllTools()) : [];
+		const configTools = promptConfig?.tools ?? this.config.tools;
+		if (mcpTools.length === 0 && (!configTools || configTools.length === 0)) return;
+		const tools = configTools ? await require_file.maybeLoadToolsFromExternalFile(configTools, vars) : [];
+		if (mcpTools.length === 0 && (!tools || tools.length === 0)) return;
+		const mcpToolNames = new Set(mcpTools.map((tool) => tool.toolSpec?.name).filter((name) => typeof name === "string"));
+		const dedupedConfigTools = (tools || []).filter((tool) => {
+			const name = tool.toolSpec?.name ?? tool.function?.name ?? tool.name;
+			if (typeof name === "string" && mcpToolNames.has(name)) {
+				require_logger.logger.warn(`[Bedrock Converse] Tool name '${name}' is defined in both config.tools and an MCP server; using the MCP-provided tool.`);
+				return false;
+			}
+			return true;
+		});
+		const converseTools = convertToolsToConverseFormat([...mcpTools, ...dedupedConfigTools]);
+		const requestedToolChoice = configToolChoice ? convertToolChoiceToConverseFormat(configToolChoice) : void 0;
+		const modelRejectsForcedToolChoice = require_util$1.isForcedToolChoiceUnsupportedClaudeModel(this.modelName);
+		const dropForcedToolChoice = (modelRejectsForcedToolChoice || require_util$1.isAlwaysOnAdaptiveThinkingClaudeModel(this.modelName)) && requestedToolChoice !== void 0 && ("any" in requestedToolChoice || "tool" in requestedToolChoice);
+		if (dropForcedToolChoice && !this.forcedToolChoiceRemovalWarned) {
+			const modelName = require_util$1.getClaudeModelWarningName(this.modelName) ?? "this Claude model";
+			require_logger.logger.warn(modelRejectsForcedToolChoice ? `Forced tool choice (any/tool) is not supported on ${modelName} and has been omitted. The model decides when to call tools; remove toolChoice to silence this warning.` : `Forced tool choice (any/tool) is incompatible with the always-on adaptive thinking of ${modelName} and has been omitted. The model decides when to call tools; remove toolChoice to silence this warning.`);
+			this.forcedToolChoiceRemovalWarned = true;
+		}
+		const toolChoice = dropForcedToolChoice ? void 0 : requestedToolChoice;
+		return {
+			tools: converseTools,
+			...toolChoice ? { toolChoice } : {}
+		};
+	}
+	getEffectiveToolChoice(promptConfig) {
+		return promptConfig?.tool_choice ?? promptConfig?.toolChoice ?? this.config.tool_choice ?? this.config.toolChoice;
+	}
+	/**
+	* Build the guardrail configuration
+	*/
+	buildGuardrailConfig() {
+		if (!this.config.guardrailIdentifier) return;
+		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 and reasoningConfig)
+	*/
+	buildAdditionalModelRequestFields() {
+		const fields = { ...this.config.additionalModelRequestFields || {} };
+		const effort = fields.output_config?.effort;
+		if (require_util$1.isSamplingParamsDeprecatedClaudeModel(this.modelName)) {
+			delete fields.temperature;
+			delete fields.top_p;
+			delete fields.top_k;
+			const additionalThinking = fields.thinking;
+			const normalizedThinking = require_util$1.normalizeClaudeThinkingConfig(this.modelName, additionalThinking, effort);
+			if (normalizedThinking === void 0) delete fields.thinking;
+			else fields.thinking = normalizedThinking;
+		}
+		if (this.config.thinking) {
+			const normalizedThinking = require_util$1.normalizeClaudeThinkingConfig(this.modelName, this.config.thinking, effort);
+			if (normalizedThinking !== void 0) fields.thinking = normalizedThinking;
+		}
+		if (this.config.reasoningConfig) fields.reasoningConfig = this.config.reasoningConfig;
+		return Object.keys(fields).length > 0 ? fields : void 0;
+	}
+	/**
+	* Build performance configuration
+	*/
+	buildPerformanceConfig() {
+		if (!this.config.performanceConfig) return;
+		return { latency: this.config.performanceConfig.latency };
+	}
+	/**
+	* Build service tier configuration
+	*/
+	buildServiceTier() {
+		if (!this.config.serviceTier) return;
+		return { type: this.config.serviceTier.type };
+	}
+	/**
+	* Main API call using Converse API
+	*/
+	async callApi(prompt, context) {
+		const initErrorResponse = await this.awaitMcpReadyForRequest(context);
+		if (initErrorResponse) return initErrorResponse;
+		const inferenceConfig = this.buildInferenceConfig();
+		const spanContext = {
+			system: "bedrock",
+			operationName: "chat",
+			model: this.modelName,
+			providerId: this.id(),
+			maxTokens: inferenceConfig?.maxTokens,
+			temperature: inferenceConfig?.temperature,
+			topP: inferenceConfig?.topP,
+			stopSequences: inferenceConfig?.stopSequences,
+			testIndex: context?.testIdx ?? context?.test?.vars?.__testIdx,
+			promptLabel: context?.prompt?.label,
+			traceparent: context?.traceparent
+		};
+		const resultExtractor = (response) => {
+			const result = {};
+			if (response.tokenUsage) result.tokenUsage = {
+				prompt: response.tokenUsage.prompt,
+				completion: response.tokenUsage.completion,
+				total: response.tokenUsage.total
+			};
+			const stopReason = response.metadata?.stopReason;
+			if (stopReason) result.finishReasons = [stopReason];
+			return result;
+		};
+		return require_genaiTracer.withGenAISpan(spanContext, () => this.callApiInternal(prompt, context), resultExtractor);
+	}
+	/**
+	* Internal implementation of callApi without tracing wrapper.
+	*/
+	async callApiInternal(prompt, context) {
+		const { messages, system } = parseConverseMessages(prompt);
+		const inferenceConfig = this.buildInferenceConfig();
+		const toolConfig = await this.buildToolConfig(context?.vars, context?.prompt?.config);
+		const toolsDisabled = this.isRequestToolsDisabled(context);
+		const guardrailConfig = this.buildGuardrailConfig();
+		const additionalModelRequestFields = this.buildAdditionalModelRequestFields();
+		const betweenToolsThinking = additionalModelRequestFields?.thinking?.type === "between_tools";
+		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 } : {}
+		};
+		require_logger.logger.debug("Calling AWS Bedrock Converse API", {
+			modelId: this.modelName,
+			messageCount: messages.length,
+			hasSystem: !!system,
+			hasTools: !!toolConfig,
+			hasThinking: !!this.config.thinking
+		});
+		const cache = await require_cache.getCache();
+		const region = this.getRegion();
+		const cacheKey = `bedrock:converse:${this.modelName}:${region}:${require_base.createBedrockCacheKeyHash({
+			config: this.config,
+			params: converseInput,
+			region
+		})}`;
+		if (require_cache.isCacheEnabled()) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				require_logger.logger.debug("Returning cached response");
+				const parsed = JSON.parse(cachedResponse);
+				return {
+					...await this.parseResponse(parsed, toolsDisabled, betweenToolsThinking),
+					cached: true
+				};
+			}
+		}
+		let response;
+		try {
+			const bedrockInstance = await this.getBedrockInstance();
+			const { ConverseCommand } = await import("@aws-sdk/client-bedrock-runtime");
+			const command = new ConverseCommand(converseInput);
+			response = await bedrockInstance.send(command);
+		} catch (err) {
+			const errorMessage = err?.message || String(err);
+			require_logger.logger.error("Bedrock Converse API error", { error: errorMessage });
+			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}` };
+		}
+		if (require_cache.isCacheEnabled()) try {
+			await cache.set(cacheKey, JSON.stringify(response));
+		} catch (err) {
+			require_logger.logger.error(`Failed to cache response: ${String(err)}`);
+		}
+		require_logger.logger.debug("Bedrock Converse API response received", {
+			stopReason: response.stopReason,
+			hasUsage: !!response.usage,
+			hasMetrics: !!response.metrics
+		});
+		return await this.parseResponse(response, toolsDisabled, betweenToolsThinking);
+	}
+	/**
+	* Resolves the effective tool choice for a request without touching the MCP
+	* client. Used by `callApi`/`callApiStreaming` to short-circuit MCP init for
+	* tool-disabled requests so a hung MCP transport never stalls them, and to supply
+	* the `toolsDisabled` flag those methods pass on to `parseResponse`.
+	*/
+	isRequestToolsDisabled(context) {
+		return isDisabledToolChoice(this.getEffectiveToolChoice(context?.prompt?.config));
+	}
+	/**
+	* Awaits MCP init only when this request actually needs MCP, then returns an
+	* error response if init failed. Tool-disabled requests skip both the wait
+	* and the error check entirely so they can proceed even with MCP offline.
+	* Returns `undefined` when the request can proceed.
+	*/
+	async awaitMcpReadyForRequest(context) {
+		if (this.isRequestToolsDisabled(context)) return;
+		if (this.initializationPromise != null) await this.initializationPromise;
+		if (!this.mcpInitError) return;
+		return { error: `Bedrock Converse MCP initialization failed: ${this.mcpInitError.message}` };
+	}
+	/**
+	* Invoke a single MCP tool and return a formatted result string plus the
+	* error string (if any). Centralizes the try/catch + error-message wrapping
+	* shared by streaming and non-streaming dispatch paths. Caller is
+	* responsible for ensuring `this.mcpClient` is non-null and that `name`
+	* matches a discovered MCP tool.
+	*/
+	async dispatchMcpToolCall(name, input) {
+		try {
+			const mcpResult = await this.mcpClient.callTool(name, parseToolInput(input));
+			if (require_util.isMcpErrorResult(mcpResult)) {
+				const msg = formatMcpToolError(name, require_util.getMcpErrorMessage(mcpResult));
+				return {
+					output: msg,
+					error: msg
+				};
+			}
+			return { output: formatMcpToolResult(name, mcpResult?.content) };
+		} catch (err) {
+			require_logger.logger.error(`[Bedrock Converse] MCP tool execution failed for ${name}: ${err}`);
+			const msg = formatMcpToolError(name, errorMessage(err));
+			return {
+				output: msg,
+				error: msg
+			};
+		}
+	}
+	/**
+	* Format streaming tool_use blocks for output. Routes blocks to MCP when
+	* MCP is enabled and a matching tool exists; otherwise falls back to
+	* default tool_use JSON serialization.
+	*/
+	async formatStreamingToolUseBlocks(blocks, toolsDisabled) {
+		const toolUseParts = [];
+		const mcpErrors = [];
+		const mcpTools = this.mcpClient?.getAllTools() ?? [];
+		for (const toolBlock of blocks) {
+			if (!toolBlock.name) continue;
+			const { value: parsedInput, failed: parseFailed } = parseStreamingToolInput(toolBlock.input);
+			const matchedMcpTool = mcpTools.find((tool) => tool.name === toolBlock.name);
+			if (toolsDisabled || !this.mcpClient || !matchedMcpTool) {
+				toolUseParts.push(JSON.stringify({
+					type: "tool_use",
+					id: toolBlock.toolUseId,
+					name: toolBlock.name,
+					input: parsedInput
+				}));
+				continue;
+			}
+			if (parseFailed) {
+				const msg = formatMcpToolError(toolBlock.name, "model emitted invalid JSON arguments");
+				toolUseParts.push(msg);
+				mcpErrors.push(msg);
+				continue;
+			}
+			const { output, error } = await this.dispatchMcpToolCall(toolBlock.name, parsedInput);
+			toolUseParts.push(output);
+			if (error) mcpErrors.push(error);
+		}
+		return {
+			toolUseParts,
+			mcpErrors
+		};
+	}
+	/**
+	* Execute MCP tool calls for the given tool_use blocks. Blocks whose name
+	* doesn't match a discovered MCP tool are skipped silently; the caller is
+	* responsible for deciding what to do with them. Returns formatted result
+	* strings and any errors encountered.
+	*/
+	async executeMcpToolCalls(blocks) {
+		const results = [];
+		const errors = [];
+		if (!this.mcpClient) return {
+			results,
+			errors
+		};
+		const tools = this.mcpClient.getAllTools();
+		for (const { name, input } of blocks) {
+			if (!name || !tools.find((tool) => tool.name === name)) continue;
+			const { output, error } = await this.dispatchMcpToolCall(name, input);
+			results.push(output);
+			if (error) errors.push(error);
+		}
+		return {
+			results,
+			errors
+		};
+	}
+	/**
+	* Parse the Converse API response into ProviderResponse format
+	*/
+	async parseResponse(response, toolsDisabled = false, betweenToolsThinking = false) {
+		const content = (response.output?.message)?.content || [];
+		const showThinking = this.config.showThinking !== false;
+		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 cacheWrite1hTokens = getOneHourCacheWriteTokens(usage?.cacheDetails);
+		const tokenUsage = {
+			prompt: promptTokens,
+			completion: completionTokens,
+			total: totalTokens || (promptTokens || 0) + (completionTokens || 0),
+			numRequests: 1
+		};
+		const cost = require_pricing.calculateBedrockCost(this.modelName, promptTokens, completionTokens, cacheReadTokens, cacheWriteTokens, this.getRegion(), this.config.serviceTier, cacheWrite1hTokens);
+		const metadata = {};
+		if (response.metrics?.latencyMs) metadata.latencyMs = response.metrics.latencyMs;
+		if (response.stopReason) metadata.stopReason = response.stopReason;
+		if (cacheReadTokens !== void 0 || cacheWriteTokens !== void 0) metadata.cacheTokens = {
+			read: cacheReadTokens,
+			write: cacheWriteTokens
+		};
+		if (response.performanceConfig) metadata.performanceConfig = response.performanceConfig;
+		if (response.serviceTier) metadata.serviceTier = response.serviceTier;
+		if (response.additionalModelResponseFields) metadata.additionalModelResponseFields = response.additionalModelResponseFields;
+		if (response.trace) metadata.trace = response.trace;
+		const guardrails = response.stopReason === "guardrail_intervened" ? {
+			flagged: true,
+			reason: "guardrail_intervened"
+		} : void 0;
+		let malformedError;
+		if (response.stopReason === "malformed_model_output") {
+			malformedError = "Model produced invalid output. The response could not be parsed correctly.";
+			metadata.isModelError = true;
+		} else if (response.stopReason === "malformed_tool_use") {
+			malformedError = "Model produced a malformed tool use request. Check tool configuration and input schema.";
+			metadata.isModelError = true;
+		}
+		const toolUseBlocks = content.filter((block) => "toolUse" in block && block.toolUse !== void 0);
+		const mcpToolNames = new Set(this.mcpClient ? this.mcpClient.getAllTools().map((tool) => tool.name) : []);
+		const dispatchResults = [];
+		const mcpErrors = [];
+		const handledIndexes = /* @__PURE__ */ new Set();
+		if (!toolsDisabled && toolUseBlocks.length > 0) {
+			const mcpEligible = [];
+			toolUseBlocks.forEach((block, idx) => {
+				const name = block.toolUse.name;
+				if (this.mcpClient && name && mcpToolNames.has(name)) mcpEligible.push({
+					idx,
+					name,
+					input: block.toolUse.input
+				});
+			});
+			if (mcpEligible.length > 0) {
+				const mcpResult = await this.executeMcpToolCalls(mcpEligible);
+				for (const { idx } of mcpEligible) handledIndexes.add(idx);
+				dispatchResults.push(...mcpResult.results);
+				mcpErrors.push(...mcpResult.errors);
+			}
+			if (this.config.functionToolCallbacks) for (let idx = 0; idx < toolUseBlocks.length; idx++) {
+				if (handledIndexes.has(idx)) continue;
+				const block = toolUseBlocks[idx];
+				const functionName = block.toolUse.name;
+				if (!functionName || !this.config.functionToolCallbacks[functionName]) continue;
+				try {
+					const args = typeof block.toolUse.input === "string" ? block.toolUse.input : JSON.stringify(block.toolUse.input || {});
+					const result = await this.executeFunctionCallback(functionName, args, block.toolUse.toolUseId);
+					dispatchResults.push(result);
+					handledIndexes.add(idx);
+				} catch (err) {
+					require_logger.logger.warn(`[Bedrock Converse] Function callback failed for ${functionName}: ${errorMessage(err)}; falling back to tool_use output`);
+				}
+			}
+		}
+		if (!toolsDisabled && toolUseBlocks.length > 0 && handledIndexes.size < toolUseBlocks.length) {
+			const fallbackText = extractTextFromContentBlocks(toolUseBlocks.filter((_, idx) => !handledIndexes.has(idx)).map((block) => ({ toolUse: block.toolUse })), showThinking);
+			if (fallbackText) dispatchResults.push(fallbackText);
+		}
+		if (dispatchResults.length > 0) {
+			if (betweenToolsThinking) {
+				const progress = extractTextFromContentBlocks(content.filter((block) => block.reasoningContent), showThinking);
+				if (progress) dispatchResults.unshift(progress);
+			}
+			const error = malformedError ?? joinMcpErrors(mcpErrors);
+			return {
+				output: dispatchResults.join("\n"),
+				tokenUsage,
+				...cost === void 0 ? {} : { cost },
+				...Object.keys(metadata).length > 0 ? { metadata } : {},
+				...guardrails ? { guardrails } : {},
+				...error ? { error } : {}
+			};
+		}
+		return {
+			output: extractTextFromContentBlocks(content, showThinking),
+			tokenUsage,
+			...cost === void 0 ? {} : { cost },
+			...Object.keys(metadata).length > 0 ? { metadata } : {},
+			...guardrails ? { guardrails } : {},
+			...malformedError ? { error: malformedError } : {}
+		};
+	}
+	/**
+	* Streaming API call using ConverseStream.
+	*
+	* Tool handling in streaming mode:
+	* - **MCP tools** ARE executed automatically when an MCP server is
+	*   configured and the model emits a `tool_use` block matching a discovered
+	*   MCP tool. Results (or error strings) are inlined in the response output.
+	* - **`functionToolCallbacks`** are NOT executed in streaming mode. Local
+	*   callback dispatch only runs in non-streaming `callApi`. Streaming
+	*   `tool_use` blocks for non-MCP tools fall through to the default
+	*   `{ "type": "tool_use", ... }` JSON serialization.
+	*
+	* Use non-streaming mode if you need automatic local callback execution.
+	*/
+	async callApiStreaming(prompt, context) {
+		const initErrorResponse = await this.awaitMcpReadyForRequest(context);
+		if (initErrorResponse) return initErrorResponse;
+		const { messages, system } = parseConverseMessages(prompt);
+		const inferenceConfig = this.buildInferenceConfig();
+		const toolConfig = await this.buildToolConfig(context?.vars, context?.prompt?.config);
+		const toolsDisabled = this.isRequestToolsDisabled(context);
+		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 } : {}
+		};
+		require_logger.logger.debug("Calling AWS Bedrock ConverseStream API", {
+			modelId: this.modelName,
+			messageCount: messages.length
+		});
+		try {
+			const bedrockInstance = await this.getBedrockInstance();
+			const { ConverseStreamCommand } = await import("@aws-sdk/client-bedrock-runtime");
+			const command = new ConverseStreamCommand(converseStreamInput);
+			const response = await bedrockInstance.send(command);
+			let output = "";
+			let reasoning = "";
+			let stopReason;
+			let usage = {};
+			const toolUseBlocks = /* @__PURE__ */ new Map();
+			const showThinking = this.config.showThinking !== false;
+			if (response.stream) for await (const event of response.stream) {
+				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;
+					}
+					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;
+			}
+			const { toolUseParts, mcpErrors } = await this.formatStreamingToolUseBlocks(Array.from(toolUseBlocks.values()), toolsDisabled);
+			const parts = [];
+			if (reasoning.trim()) 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");
+			let malformedError;
+			const metadata = {};
+			if (stopReason) metadata.stopReason = stopReason;
+			if (stopReason === "malformed_model_output") {
+				malformedError = "Model produced invalid output. The response could not be parsed correctly.";
+				metadata.isModelError = true;
+			} else if (stopReason === "malformed_tool_use") {
+				malformedError = "Model produced a malformed tool use request. Check tool configuration and input schema.";
+				metadata.isModelError = true;
+			}
+			const tokenUsage = {
+				prompt: usage.inputTokens,
+				completion: usage.outputTokens,
+				total: usage.totalTokens || (usage.inputTokens || 0) + (usage.outputTokens || 0),
+				numRequests: 1
+			};
+			const cost = require_pricing.calculateBedrockCost(this.modelName, usage.inputTokens, usage.outputTokens, usage.cacheReadInputTokens, usage.cacheWriteInputTokens, this.getRegion(), this.config.serviceTier, getOneHourCacheWriteTokens(usage.cacheDetails));
+			const error = malformedError ?? joinMcpErrors(mcpErrors);
+			return {
+				output: finalOutput,
+				tokenUsage,
+				...cost === void 0 ? {} : { cost },
+				...Object.keys(metadata).length > 0 ? { metadata } : {},
+				...error ? { error } : {}
+			};
+		} catch (err) {
+			return { error: `Bedrock ConverseStream API error: ${err?.message || String(err)}` };
+		}
+	}
+};
+//#endregion
+//#region src/providers/families/aws.ts
+const NOVA_SONIC_MODEL_IDS = /* @__PURE__ */ new Set(["amazon.nova-sonic-v1:0", "amazon.nova-2-sonic-v1:0"]);
+function isUnsupportedNovaSonicGeoId(modelName) {
+	return /^[^.]+\.amazon\.nova(?:-2)?-sonic-v1:0$/.test(modelName);
+}
+const awsProviderFactories = [
+	{
+		test: (providerPath) => providerPath.startsWith("bedrock:"),
+		create: async (providerPath, providerOptions) => {
+			const splits = providerPath.split(":");
+			const modelType = splits[1];
+			const modelName = splits.slice(2).join(":");
+			const textRoute = require_routing.getBedrockTextRoute(providerPath);
+			const isLegacyType = modelType === "converse" || modelType === "completion";
+			const bareModelName = splits.slice(1).join(":");
+			const novaSonicSubtype = modelType === "nova-sonic" ? {
+				expectedModel: "amazon.nova-sonic-v1:0",
+				name: "nova-sonic"
+			} : modelType === "nova-2-sonic" ? {
+				expectedModel: "amazon.nova-2-sonic-v1:0",
+				name: "nova-2-sonic"
+			} : void 0;
+			if (novaSonicSubtype && modelName) {
+				if (!NOVA_SONIC_MODEL_IDS.has(modelName)) throw new Error(`Amazon Bedrock model "${modelName}" is an unsupported Nova Sonic model ID. Use "bedrock:${novaSonicSubtype.name}:${novaSonicSubtype.expectedModel}".`);
+				if (modelName !== novaSonicSubtype.expectedModel) throw new Error(`Amazon Bedrock model "${modelName}" does not match provider subtype "${novaSonicSubtype.name}". Use "bedrock:${novaSonicSubtype.name}:${novaSonicSubtype.expectedModel}".`);
+			}
+			const requestedNovaSonicModel = novaSonicSubtype && !modelName ? novaSonicSubtype.expectedModel : NOVA_SONIC_MODEL_IDS.has(bareModelName) ? bareModelName : (modelType === "nova-sonic" || modelType === "nova-2-sonic") && NOVA_SONIC_MODEL_IDS.has(modelName) ? modelName : void 0;
+			if (isUnsupportedNovaSonicGeoId(bareModelName) || isUnsupportedNovaSonicGeoId(modelName)) {
+				const rejectedModel = isUnsupportedNovaSonicGeoId(bareModelName) ? bareModelName : modelName;
+				const unprefixedModel = rejectedModel.replace(/^[^.]+\./, "");
+				throw new Error(`Amazon Bedrock model "${rejectedModel}" does not support geo inference IDs. Use the bare "bedrock:${unprefixedModel}" model ID in a supported region.`);
+			}
+			if (isLegacyType && NOVA_SONIC_MODEL_IDS.has(modelName)) throw new Error(`Amazon Bedrock model "${modelName}" supports only InvokeModelWithBidirectionalStream, not Converse or InvokeModel. Use its bare bedrock model ID.`);
+			if (requestedNovaSonicModel) {
+				const { NovaSonicProvider } = await Promise.resolve().then(() => require("./nova-sonic-CaSSA3Jq.cjs"));
+				return new NovaSonicProvider(requestedNovaSonicModel, providerOptions);
+			}
+			const anthropicModel = modelType === "messages" ? modelName : splits.length === 2 ? splits[1] : isLegacyType ? modelName : void 0;
+			if (anthropicModel && require_routing.isRejectedPrefixedMythosId(anthropicModel)) throw new Error(`Amazon Bedrock model "${anthropicModel}" is not a valid Mythos model ID. Use "bedrock:anthropic.claude-mythos-5"; Mythos does not support geo or global inference IDs.`);
+			if (anthropicModel && /^(?:(?:us|global)\.)?anthropic\.claude-/.test(anthropicModel)) {
+				const { createBedrockAnthropicMessagesProvider } = await Promise.resolve().then(() => require("./anthropicMessages-C8m9Whrd.cjs"));
+				if (require_routing.requiresBedrockAnthropicMessagesModel(anthropicModel) && isLegacyType) throw new Error(`Amazon Bedrock model "${anthropicModel}" uses the Anthropic Messages API, not ${modelType === "converse" ? "Converse" : "InvokeModel"}. Use "bedrock:${anthropicModel}" or "bedrock:messages:${anthropicModel}".`);
+				if (require_routing.isBedrockAnthropicMessagesModel(anthropicModel) && textRoute?.apiMode === "messages") return createBedrockAnthropicMessagesProvider(anthropicModel, {
+					...providerOptions,
+					id: providerOptions.id ?? providerPath
+				});
+			}
+			if (modelType === "messages") throw new Error(`Amazon Bedrock model "${modelName}" is not supported by the Anthropic Messages provider. Use a us. or global. inference profile for Fable/Mythos 5.1. Mantle supports anthropic.claude-fable-5, anthropic.claude-mythos-5, and anthropic.claude-fable-5-1 (GovCloud West).`);
+			if (modelType === "responses") {
+				if (!modelName) throw new Error("Amazon Bedrock Responses providers require a model id. Use bedrock:responses:<model-id>, for example bedrock:responses:openai.gpt-oss-120b.");
+				const { createBedrockOpenAiResponsesProvider } = await Promise.resolve().then(() => require("./openaiResponses-DYPZEMX1.cjs"));
+				return createBedrockOpenAiResponsesProvider(modelName, {
+					...providerOptions,
+					id: providerOptions.id ?? providerPath
+				});
+			}
+			const candidateResponsesModel = modelType === "converse" || modelType === "completion" ? modelName : splits.length === 2 ? splits[1] : void 0;
+			const routedGrokModel = modelType === "mantle" ? modelName : candidateResponsesModel;
+			if (routedGrokModel && require_routing.isRejectedPrefixedGrokId(routedGrokModel, modelType === "mantle")) throw new Error(`Amazon Bedrock model "${routedGrokModel}" is not a valid Grok mantle id. Use the bare "bedrock:xai.grok-4.3" id for mantle-served Grok models, or an inference profile such as "bedrock:converse:us.xai.grok-4.6" for Grok models Bedrock serves natively.`);
+			if (textRoute?.apiMode === "responses") {
+				const { createBedrockOpenAiResponsesProvider } = await Promise.resolve().then(() => require("./openaiResponses-DYPZEMX1.cjs"));
+				return createBedrockOpenAiResponsesProvider(textRoute.modelId, {
+					...providerOptions,
+					id: providerOptions.id ?? providerPath
+				});
+			}
+			if (modelType === "mantle") {
+				const { createBedrockMantleChatProvider } = await Promise.resolve().then(() => require("./mantleChat-CcE-zjfj.cjs"));
+				return createBedrockMantleChatProvider(modelName, {
+					...providerOptions,
+					id: providerOptions.id ?? providerPath
+				});
+			}
+			if (modelType === "converse") {
+				const { assertBedrockModelIsAvailable } = await Promise.resolve().then(() => require("./bedrock-BP17ZXbR.cjs"));
+				assertBedrockModelIsAvailable(modelName);
+				return new AwsBedrockConverseProvider(modelName, providerOptions);
+			}
+			if (modelType.includes("luma.ray") || modelName.includes("luma.ray")) {
+				const { LumaRayVideoProvider } = await Promise.resolve().then(() => require("./luma-ray-DCf5fnrz.cjs"));
+				return new LumaRayVideoProvider(modelName.includes("luma.ray") ? modelName : splits.slice(1).join(":"), providerOptions);
+			}
+			if (modelType.includes("amazon.nova-reel") || modelType === "video" && (modelName.includes("amazon.nova-reel") || modelName === "")) {
+				const { NovaReelVideoProvider } = await Promise.resolve().then(() => require("./nova-reel-BiOMUm5q.cjs"));
+				return new NovaReelVideoProvider(modelType === "video" ? modelName || "amazon.nova-reel-v1:1" : splits.slice(1).join(":"), providerOptions);
+			}
+			if (modelType === "agents") {
+				const { AwsBedrockAgentsProvider } = await Promise.resolve().then(() => require("./agents-F2rhx0iL.cjs"));
+				return new AwsBedrockAgentsProvider(modelName, providerOptions);
+			}
+			if (modelType === "completion") return new AwsBedrockCompletionProvider(modelName, providerOptions);
+			if (modelType === "embeddings" || modelType === "embedding") return new AwsBedrockEmbeddingProvider(modelName, providerOptions);
+			if (modelType === "kb" || modelType === "knowledge-base") {
+				const { AwsBedrockKnowledgeBaseProvider } = await Promise.resolve().then(() => require("./knowledgeBase-DpoMw1IH.cjs"));
+				return new AwsBedrockKnowledgeBaseProvider(modelName, providerOptions);
+			}
+			return new AwsBedrockCompletionProvider(splits.slice(1).join(":"), providerOptions);
+		}
+	},
+	{
+		test: (providerPath) => providerPath.startsWith("bedrock-agent:"),
+		create: async (providerPath, providerOptions) => {
+			const agentId = providerPath.substring(14);
+			const { AwsBedrockAgentsProvider } = await Promise.resolve().then(() => require("./agents-F2rhx0iL.cjs"));
+			return new AwsBedrockAgentsProvider(agentId, providerOptions);
+		}
+	},
+	{
+		test: (providerPath) => providerPath.startsWith("sagemaker:"),
+		create: async (providerPath, providerOptions) => {
+			const splits = providerPath.split(":");
+			const modelType = splits[1];
+			const endpointName = splits.slice(2).join(":");
+			const { SageMakerCompletionProvider, SageMakerEmbeddingProvider } = await Promise.resolve().then(() => require("./sagemaker-B8D0L4rj.cjs"));
+			if (modelType === "embedding" || modelType === "embeddings") return new SageMakerEmbeddingProvider(endpointName || modelType, providerOptions);
+			if (splits.length === 2) return new SageMakerCompletionProvider(modelType, providerOptions);
+			return new SageMakerCompletionProvider(endpointName, {
+				...providerOptions,
+				config: {
+					...providerOptions.config,
+					modelType
+				}
+			});
+		}
+	}
+];
+//#endregion
+exports.AWS_BEDROCK_MODELS = AWS_BEDROCK_MODELS;
+exports.AwsBedrockCompletionProvider = AwsBedrockCompletionProvider;
+exports.AwsBedrockEmbeddingProvider = AwsBedrockEmbeddingProvider;
+exports.BEDROCK_MODEL = BEDROCK_MODEL;
+exports.LlamaVersion = LlamaVersion;
+exports.RETIRED_BEDROCK_MODELS = RETIRED_BEDROCK_MODELS;
+exports.addConfigParam = addConfigParam;
+exports.assertBedrockModelIsAvailable = assertBedrockModelIsAvailable;
+exports.awsProviderFactories = awsProviderFactories;
+exports.coerceStrToNum = coerceStrToNum;
+exports.extractTextAndImages = extractTextAndImages;
+exports.extractTextContent = extractTextContent;
+exports.formatPromptLlama2Chat = formatPromptLlama2Chat;
+exports.formatPromptLlama32Vision = formatPromptLlama32Vision;
+exports.formatPromptLlama3Instruct = formatPromptLlama3Instruct;
+exports.formatPromptLlama4 = formatPromptLlama4;
+exports.getHandlerForModel = getHandlerForModel;
+exports.getLlamaModelHandler = getLlamaModelHandler;
+exports.parseValue = parseValue;
+
+//# sourceMappingURL=aws-qskKGczY.cjs.map