promptfoo 0.125.0 → 0.125.1

package/dist/src/bedrock-CsjM1dOt.js

@@ -0,0 +1,1300 @@
+#!/usr/bin/env node
+import { Q as getEnvString, X as getEnvInt, Y as getEnvFloat, c as logger } from "./logger-pCNnmVuz.js";
+import { f as parseChatPrompt } from "./shared-DS_sDrmK.js";
+import { c as maybeLoadToolsFromExternalFile } from "./file-DnhgJopr.js";
+import "./util-Cj9drvOY.js";
+import { d as isCacheEnabled, o as getCache } from "./cache-D-9eZN3I.js";
+import { d as createEmptyTokenUsage } from "./tokenUsageUtils-CHs91tUW.js";
+import { A as parseMessages, C as isForcedToolChoiceUnsupportedClaudeModel, M as resolveClaudeSamplingParams, O as normalizeClaudeThinkingConfig, T as isThinkingOnByDefaultClaudeModel, f as getTokenUsage, k as outputFromMessage, p as isAlwaysOnAdaptiveThinkingClaudeModel, s as clampMaxTokensForThinkingBudget, w as isSamplingParamsDeprecatedClaudeModel, x as isClaudeThinkingEnabled } from "./util-TfpE49TI.js";
+import { u as requiresBedrockAnthropicMessagesModel } from "./routing-D4szcohi.js";
+import { c as novaParseMessages, i as INFERENCE_PROFILE_PREFIX, n as createBedrockCacheKeyHash, s as novaOutputFromMessage, t as AwsBedrockGenericProvider } from "./base-DyLOZ_iX.js";
+import { i as isBedrockGrok46Profile, n as calculateBedrockInvokeModelCost } from "./pricing-BLSYUBjO.js";
+import dedent from "dedent";
+import Anthropic from "@anthropic-ai/sdk";
+//#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: parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]) };
+		addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("MISTRAL_MAX_TOKENS"), 1024);
+		addConfigParam(params, "temperature", config?.temperature, getEnvFloat("MISTRAL_TEMPERATURE"), 0);
+		addConfigParam(params, "top_p", config?.top_p, 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: parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]) };
+		addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+		addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+		addConfigParam(params, "top_p", config?.top_p, 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`
+      <|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`
+      <|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`<|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 = 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, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(params, "max_gen_len", config?.max_gen_len, 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: parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			addConfigParam(params, "stop", config?.stop, getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, 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 } = novaParseMessages(prompt);
+					messages = extractedMessages;
+					if (system) systemPrompt = [{ text: system }];
+				}
+			} catch {
+				const { system, extractedMessages } = 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, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(inferenceConfig, "temperature", config?.interfaceConfig?.temperature, 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) => 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 } = novaParseMessages(prompt);
+					messages = extractedMessages;
+					if (system) systemPrompt = [{ text: system }];
+				}
+			} catch {
+				const { system, extractedMessages } = 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, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			if (!reasoningEnabled) addConfigParam(inferenceConfig, "temperature", config?.interfaceConfig?.temperature, 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 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.HUMAN_PROMPT} ${prompt} ${Anthropic.AI_PROMPT}`,
+				stop_sequences: stop
+			};
+			addConfigParam(params, "max_tokens_to_sample", config?.max_tokens_to_sample, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), 1024);
+			addConfigParam(params, "temperature", config?.temperature, 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 } = parseMessages(prompt);
+					messages = extractedMessages;
+					systemPrompt = system;
+				}
+			} catch {
+				const { system, extractedMessages } = 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 && isAlwaysOnAdaptiveThinkingClaudeModel(modelName);
+			const thinksByDefault = alwaysOnAdaptiveThinking || !!modelName && isThinkingOnByDefaultClaudeModel(modelName) && config?.thinking?.type !== "disabled" && config?.thinking?.type !== "between_tools";
+			addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), thinksByDefault ? 2048 : 1024);
+			const thinking = modelName ? normalizeClaudeThinkingConfig(modelName, config?.thinking, void 0) : config?.thinking;
+			const { sampling, warnings: samplingWarnings } = resolveClaudeSamplingParams({ temperature: config?.temperature }, {
+				thinkingEnabled: alwaysOnAdaptiveThinking || isClaudeThinkingEnabled(thinking),
+				samplingParamsDeprecated: modelName ? isSamplingParamsDeprecatedClaudeModel(modelName) : false,
+				defaultTemperature: 0
+			});
+			for (const warning of samplingWarnings) logger.warn(warning);
+			addConfigParam(params, "temperature", sampling.temperature, void 0, void 0);
+			addConfigParam(params, "tools", await maybeLoadToolsFromExternalFile(config?.tools, vars), void 0, void 0);
+			addConfigParam(params, "tool_choice", (alwaysOnAdaptiveThinking || !!modelName && 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 = clampMaxTokensForThinkingBudget(params.max_tokens, thinking);
+			if (systemPrompt) addConfigParam(params, "system", systemPrompt, void 0, void 0);
+			return params;
+		},
+		output: (config, responseJson) => {
+			return 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 {
+				...getTokenUsage({ usage: normalizedUsage }, false),
+				numRequests: 1
+			};
+		}
+	},
+	TITAN_TEXT: {
+		params: async (config, prompt, stop, _modelName) => {
+			const textGenerationConfig = {};
+			addConfigParam(textGenerationConfig, "maxTokenCount", config?.textGenerationConfig?.maxTokenCount, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), 1024);
+			addConfigParam(textGenerationConfig, "temperature", config?.textGenerationConfig?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(textGenerationConfig, "topP", config?.textGenerationConfig?.topP, 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, getEnvFloat("COHERE_TEMPERATURE"), 0);
+			addConfigParam(params, "p", config?.p, getEnvFloat("COHERE_P"), 1);
+			addConfigParam(params, "k", config?.k, getEnvInt("COHERE_K"), 0);
+			addConfigParam(params, "max_tokens", config?.max_tokens, 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 = 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 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, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, 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, getEnvInt("MISTRAL_MAX_TOKENS"), 1024);
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("MISTRAL_TEMPERATURE"), 0);
+			addConfigParam(params, "top_p", config?.top_p, getEnvFloat("MISTRAL_TOP_P"), 1);
+			addConfigParam(params, "top_k", config?.top_k, 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: parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_completion_tokens", config?.max_completion_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), .1);
+			addConfigParam(params, "top_p", config?.top_p, 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, getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, 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: parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"), void 0);
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"), .7);
+			addConfigParam(params, "top_p", config?.top_p, getEnvFloat("AWS_BEDROCK_TOP_P"), 1);
+			if (stop && stop.length > 0 || config?.stop) addConfigParam(params, "stop", stop || config?.stop, getEnvString("AWS_BEDROCK_STOP"));
+			addConfigParam(params, "frequency_penalty", config?.frequency_penalty, getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			addConfigParam(params, "tools", await 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: parseChatPrompt(prompt, [{
+				role: "user",
+				content: prompt
+			}]) };
+			addConfigParam(params, "max_tokens", config?.max_tokens, getEnvInt("AWS_BEDROCK_MAX_TOKENS"));
+			addConfigParam(params, "temperature", config?.temperature, getEnvFloat("AWS_BEDROCK_TEMPERATURE"));
+			addConfigParam(params, "top_p", config?.top_p, 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, getEnvFloat("AWS_BEDROCK_FREQUENCY_PENALTY"));
+			addConfigParam(params, "presence_penalty", config?.presence_penalty, getEnvFloat("AWS_BEDROCK_PRESENCE_PENALTY"));
+			addConfigParam(params, "reasoning_effort", config?.reasoning_effort);
+			addConfigParam(params, "tools", await 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 (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(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 AwsBedrockGenericProvider {
+	static AWS_BEDROCK_COMPLETION_MODELS = Object.keys(AWS_BEDROCK_MODELS);
+	async callApi(prompt, context) {
+		let stop;
+		try {
+			stop = getEnvString("AWS_BEDROCK_STOP") ? JSON.parse(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) {
+			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);
+		logger.debug("Calling Amazon Bedrock API", { params });
+		const cache = await getCache();
+		const region = this.getRegion();
+		const cacheKey = `bedrock:${this.modelName}:${region}:${createBedrockCacheKeyHash({
+			config: this.config,
+			params,
+			region
+		})}`;
+		if (isCacheEnabled()) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				logger.debug(`Returning cached response for ${prompt}: ${cachedResponse}`);
+				return {
+					output: model.output(mergedConfig, JSON.parse(cachedResponse)),
+					tokenUsage: createEmptyTokenUsage(),
+					cached: true
+				};
+			}
+		}
+		let response;
+		try {
+			const bedrockInstance = await this.getBedrockInstance();
+			try {
+				const testCredentials = await bedrockInstance.config.credentials?.();
+				logger.debug(`Actual credentials being used: ${testCredentials?.accessKeyId ? `accessKeyId starts with: ${testCredentials.accessKeyId.substring(0, 4)}...` : "no explicit credentials (using instance metadata)"}`);
+			} catch (credErr) {
+				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)}` };
+		}
+		logger.debug(`Amazon Bedrock API response: ${response.body.transformToString()}`);
+		if (isCacheEnabled()) try {
+			await cache.set(cacheKey, new TextDecoder().decode(response.body));
+		} catch (err) {
+			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);
+				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) logger.debug(`No explicit token counts found for ${this.modelName}, tracking request count only`);
+				else logger.debug(`Extracted token usage: ${JSON.stringify(tokenUsage)}`);
+			}
+			if (!tokenUsage.numRequests) tokenUsage.numRequests = 1;
+			const cacheReadInputTokens = tokenUsage.completionDetails?.cacheReadInputTokens ?? (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) : isBedrockGrok46Profile(this.modelName) && tokenUsage.prompt !== void 0 ? Math.max(tokenUsage.prompt - (cacheReadInputTokens ?? 0), 0) : tokenUsage.prompt;
+			const cost = 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) {
+			logger.error("Bedrock API response error", {
+				error: String(err),
+				response
+			});
+			return { error: `API response error: ${String(err)}: ${JSON.stringify(response)}` };
+		}
+	}
+};
+var AwsBedrockEmbeddingProvider = class extends 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 };
+		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)}` };
+		}
+		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
+export { getLlamaModelHandler as _, LlamaVersion as a, assertBedrockModelIsAvailable as c, extractTextContent as d, formatPromptLlama2Chat as f, getHandlerForModel as g, formatPromptLlama4 as h, BEDROCK_MODEL as i, coerceStrToNum as l, formatPromptLlama3Instruct as m, AwsBedrockCompletionProvider as n, RETIRED_BEDROCK_MODELS as o, formatPromptLlama32Vision as p, AwsBedrockEmbeddingProvider as r, addConfigParam as s, AWS_BEDROCK_MODELS as t, extractTextAndImages as u, parseValue as v };
+
+//# sourceMappingURL=bedrock-CsjM1dOt.js.map