promptfoo 0.125.0 → 0.125.1

package/dist/src/aws-DHtuUIzQ.js

@@ -1,1149 +0,0 @@
-#!/usr/bin/env node
-import { Q as getEnvString, X as getEnvInt, Y as getEnvFloat, c as logger } from "./logger-pCNnmVuz.js";
-import { d as openaiToolsToBedrock, o as isOpenAIToolArray, s as isOpenAIToolChoice, u as openaiToolChoiceToBedrock } from "./shared-DS_sDrmK.js";
-import { n as telemetry } from "./telemetry-Cix90qqz.js";
-import { c as maybeLoadToolsFromExternalFile } from "./file-DnhgJopr.js";
-import "./util-BD1R_PsR.js";
-import { t as providerRegistry } from "./providerRegistry-wn1xUT6S.js";
-import { h as withGenAISpan } from "./genaiTracer-j8OXa5Va.js";
-import { d as isCacheEnabled, o as getCache } from "./cache-CdaZNb75.js";
-import { c as normalizeMcpToolContent, i as getMcpErrorMessage, o as isMcpErrorResult } from "./util-C72P0iIa.js";
-import { n as executeProviderFunctionCallback, r as loadProviderCallbackFromFileUrl } from "./functionCallbackUtils-BCAdWfHO.js";
-import { t as MCPClient } from "./client-BFf1r6Z8.js";
-import { C as isForcedToolChoiceUnsupportedClaudeModel, M as resolveClaudeSamplingParams, O as normalizeClaudeThinkingConfig, l as getClaudeModelWarningName, p as isAlwaysOnAdaptiveThinkingClaudeModel, w as isSamplingParamsDeprecatedClaudeModel, x as isClaudeThinkingEnabled } from "./util-TfpE49TI.js";
-import { c as isRejectedPrefixedGrokId, l as isRejectedPrefixedMythosId, n as isBedrockAnthropicMessagesModel, t as getBedrockTextRoute, u as requiresBedrockAnthropicMessagesModel } from "./routing-D4szcohi.js";
-import { n as createBedrockCacheKeyHash, t as AwsBedrockGenericProvider } from "./base-Br-G_Xou.js";
-import { t as calculateBedrockCost } from "./pricing-BLSYUBjO.js";
-import { n as AwsBedrockCompletionProvider, r as AwsBedrockEmbeddingProvider } from "./bedrock-BdMru_ro.js";
-//#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 (isOpenAIToolArray(tools)) return 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)) {
-			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) {
-			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}): ${normalizeMcpToolContent(content, (part) => {
-		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) {
-		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 (isOpenAIToolChoice(toolChoice)) return 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 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 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 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 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) telemetry.record("feature_used", {
-			feature: "extended_thinking",
-			provider: "bedrock_converse"
-		});
-		if (this.config.reasoningConfig?.type === "enabled") telemetry.record("feature_used", {
-			feature: "nova2_reasoning",
-			provider: "bedrock_converse"
-		});
-		if (this.config.tools) 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));
-			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 MCPClient(this.config.mcp);
-		if (!this.registeredForShutdown) {
-			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) {
-			logger.warn(`[Bedrock Converse] MCP init had failed; cleaning up anyway: ${errorMessage(err)}`);
-		}
-		if (this.mcpClient) {
-			try {
-				await this.mcpClient.cleanup();
-			} catch (err) {
-				logger.error(`[Bedrock Converse] MCP client cleanup failed: ${errorMessage(err)}`);
-			}
-			this.mcpClient = null;
-		}
-		this.initializationPromise = null;
-		if (this.registeredForShutdown) {
-			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 loadProviderCallbackFromFileUrl(fileRef, "[Bedrock Converse]");
-	}
-	/**
-	* Executes a function callback with proper error handling
-	*/
-	async executeFunctionCallback(functionName, args, callId) {
-		return 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 ?? getEnvInt("AWS_BEDROCK_MAX_TOKENS") ?? void 0;
-		const temperatureValue = this.config.temperature ?? getEnvFloat("AWS_BEDROCK_TEMPERATURE") ?? void 0;
-		const topPValue = this.config.topP ?? this.config.top_p ?? getEnvFloat("AWS_BEDROCK_TOP_P");
-		let stopSequences = this.config.stopSequences || this.config.stop;
-		if (!stopSequences) {
-			const envStop = getEnvString("AWS_BEDROCK_STOP");
-			if (envStop) try {
-				stopSequences = JSON.parse(envStop);
-			} catch {}
-		}
-		const maxTokens = reasoningEnabled && isHighEffort ? void 0 : maxTokensValue;
-		const samplingParamsDeprecated = 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 } = resolveClaudeSamplingParams({
-				temperature,
-				top_p: topP
-			}, {
-				thinkingEnabled: isClaudeThinkingEnabled(this.config.thinking ?? rawThinking),
-				samplingParamsDeprecated
-			});
-			for (const warning of warnings) 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 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)) {
-				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 = isForcedToolChoiceUnsupportedClaudeModel(this.modelName);
-		const dropForcedToolChoice = (modelRejectsForcedToolChoice || isAlwaysOnAdaptiveThinkingClaudeModel(this.modelName)) && requestedToolChoice !== void 0 && ("any" in requestedToolChoice || "tool" in requestedToolChoice);
-		if (dropForcedToolChoice && !this.forcedToolChoiceRemovalWarned) {
-			const modelName = getClaudeModelWarningName(this.modelName) ?? "this Claude model";
-			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 (isSamplingParamsDeprecatedClaudeModel(this.modelName)) {
-			delete fields.temperature;
-			delete fields.top_p;
-			delete fields.top_k;
-			const additionalThinking = fields.thinking;
-			const normalizedThinking = normalizeClaudeThinkingConfig(this.modelName, additionalThinking, effort);
-			if (normalizedThinking === void 0) delete fields.thinking;
-			else fields.thinking = normalizedThinking;
-		}
-		if (this.config.thinking) {
-			const normalizedThinking = 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 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 } : {}
-		};
-		logger.debug("Calling AWS Bedrock Converse API", {
-			modelId: this.modelName,
-			messageCount: messages.length,
-			hasSystem: !!system,
-			hasTools: !!toolConfig,
-			hasThinking: !!this.config.thinking
-		});
-		const cache = await getCache();
-		const region = this.getRegion();
-		const cacheKey = `bedrock:converse:${this.modelName}:${region}:${createBedrockCacheKeyHash({
-			config: this.config,
-			params: converseInput,
-			region
-		})}`;
-		if (isCacheEnabled()) {
-			const cachedResponse = await cache.get(cacheKey);
-			if (cachedResponse) {
-				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);
-			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 (isCacheEnabled()) try {
-			await cache.set(cacheKey, JSON.stringify(response));
-		} catch (err) {
-			logger.error(`Failed to cache response: ${String(err)}`);
-		}
-		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 (isMcpErrorResult(mcpResult)) {
-				const msg = formatMcpToolError(name, getMcpErrorMessage(mcpResult));
-				return {
-					output: msg,
-					error: msg
-				};
-			}
-			return { output: formatMcpToolResult(name, mcpResult?.content) };
-		} catch (err) {
-			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 = 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) {
-					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 } : {}
-		};
-		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 = 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 = 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 import("./nova-sonic-DJS22fC3.js");
-				return new NovaSonicProvider(requestedNovaSonicModel, providerOptions);
-			}
-			const anthropicModel = modelType === "messages" ? modelName : splits.length === 2 ? splits[1] : isLegacyType ? modelName : void 0;
-			if (anthropicModel && 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 import("./anthropicMessages-AcNWTpYO.js");
-				if (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 (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 import("./openaiResponses-CKSl5Sdg.js");
-				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 && 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 import("./openaiResponses-CKSl5Sdg.js");
-				return createBedrockOpenAiResponsesProvider(textRoute.modelId, {
-					...providerOptions,
-					id: providerOptions.id ?? providerPath
-				});
-			}
-			if (modelType === "mantle") {
-				const { createBedrockMantleChatProvider } = await import("./mantleChat-wBfAX46o.js");
-				return createBedrockMantleChatProvider(modelName, {
-					...providerOptions,
-					id: providerOptions.id ?? providerPath
-				});
-			}
-			if (modelType === "converse") {
-				const { assertBedrockModelIsAvailable } = await import("./bedrock-DBDxBaF9.js");
-				assertBedrockModelIsAvailable(modelName);
-				return new AwsBedrockConverseProvider(modelName, providerOptions);
-			}
-			if (modelType.includes("luma.ray") || modelName.includes("luma.ray")) {
-				const { LumaRayVideoProvider } = await import("./luma-ray-DAvKrInz.js");
-				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 import("./nova-reel-BtyBXq5M.js");
-				return new NovaReelVideoProvider(modelType === "video" ? modelName || "amazon.nova-reel-v1:1" : splits.slice(1).join(":"), providerOptions);
-			}
-			if (modelType === "agents") {
-				const { AwsBedrockAgentsProvider } = await import("./agents-OcF9hq--.js");
-				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 import("./knowledgeBase-C0IaCCVs.js");
-				return new AwsBedrockKnowledgeBaseProvider(modelName, providerOptions);
-			}
-			const fullModelName = splits.slice(1).join(":");
-			return new AwsBedrockCompletionProvider(fullModelName, providerOptions);
-		}
-	},
-	{
-		test: (providerPath) => providerPath.startsWith("bedrock-agent:"),
-		create: async (providerPath, providerOptions) => {
-			const agentId = providerPath.substring(14);
-			const { AwsBedrockAgentsProvider } = await import("./agents-OcF9hq--.js");
-			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 import("./sagemaker-Bt3JUAWq.js");
-			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
-export { awsProviderFactories };
-
-//# sourceMappingURL=aws-DHtuUIzQ.js.map