promptfoo 0.125.0 → 0.125.1

package/dist/src/util-LEbeiYw_.js

@@ -0,0 +1,743 @@
+import { r as parseDataUrl } from "./dataUrl-DUSr-ZvI.js";
+import { n as calculateCost } from "./shared-BnN4RWgk.js";
+//#region src/providers/anthropic/util.ts
+const ANTHROPIC_MODELS = [
+	...modelsWithCost([
+		"claude-fable-5-1",
+		"claude-mythos-5-1",
+		"claude-fable-5",
+		"claude-mythos-5"
+	], {
+		input: 10 / 1e6,
+		output: 50 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-5-5"], {
+		input: 4 / 1e6,
+		output: 20 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-5"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost(["claude-sonnet-5-5"], {
+		input: 2 / 1e6,
+		output: 10 / 1e6
+	}),
+	...modelsWithCost(["claude-sonnet-5"], {
+		input: 2 / 1e6,
+		output: 10 / 1e6
+	}),
+	...modelsWithCost(["claude-mythos-preview"], {
+		input: 25 / 1e6,
+		output: 125 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-4-8"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-4-7"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost(["claude-sonnet-4-6"], {
+		input: 3 / 1e6,
+		output: 15 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-4-6"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-4-5", "claude-opus-4-5-20251101"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost([
+		"claude-opus-4-1",
+		"claude-opus-4-1-20250805",
+		"claude-opus-4-20250514",
+		"claude-opus-4-0"
+	], {
+		input: 15 / 1e6,
+		output: 75 / 1e6
+	}),
+	...modelsWithCost([
+		"claude-sonnet-4-5",
+		"claude-sonnet-4-5-20250929",
+		"claude-sonnet-4-5-latest",
+		"claude-sonnet-4-20250514",
+		"claude-sonnet-4-0"
+	], {
+		input: 3 / 1e6,
+		output: 15 / 1e6
+	}),
+	...modelsWithCost(["claude-haiku-4-5", "claude-haiku-4-5-20251001"], {
+		input: 1 / 1e6,
+		output: 5 / 1e6
+	}),
+	...modelsWithCost(["claude-2.0"], {
+		input: .008 / 1e3,
+		output: .024 / 1e3
+	}),
+	...modelsWithCost(["claude-2.1"], {
+		input: .008 / 1e3,
+		output: .024 / 1e3
+	}),
+	...modelsWithCost(["claude-3-haiku-20240307"], {
+		input: 25e-5 / 1e3,
+		output: .00125 / 1e3
+	}),
+	...modelsWithCost(["claude-3-opus-20240229"], {
+		input: .015 / 1e3,
+		output: .075 / 1e3
+	}),
+	...modelsWithCost(["claude-3-5-haiku-20241022"], {
+		input: .8 / 1e6,
+		output: 4 / 1e6
+	}),
+	...modelsWithCost([
+		"claude-3-5-sonnet-20240620",
+		"claude-3-5-sonnet-20241022",
+		"claude-3-7-sonnet-20250219"
+	], {
+		input: 3 / 1e6,
+		output: 15 / 1e6
+	})
+];
+const ANTHROPIC_COMPATIBILITY_ALIAS_MODELS = [
+	...modelsWithCost(["claude-opus-4-6-latest", "claude-opus-4-5-latest"], {
+		input: 5 / 1e6,
+		output: 25 / 1e6
+	}),
+	...modelsWithCost(["claude-sonnet-4-6-latest"], {
+		input: 3 / 1e6,
+		output: 15 / 1e6
+	}),
+	...modelsWithCost(["claude-haiku-4-5-latest"], {
+		input: 1 / 1e6,
+		output: 5 / 1e6
+	}),
+	...modelsWithCost(["claude-opus-4-latest"], {
+		input: 15 / 1e6,
+		output: 75 / 1e6
+	}),
+	...modelsWithCost(["claude-sonnet-4-latest"], {
+		input: 3 / 1e6,
+		output: 15 / 1e6
+	})
+];
+const ANTHROPIC_SHORTHAND_MODEL_IDS = /* @__PURE__ */ new Set([...ANTHROPIC_MODELS.map((model) => model.id), ...ANTHROPIC_COMPATIBILITY_ALIAS_MODELS.map((model) => model.id)]);
+const CLAUDE_FABLE_MYTHOS_5_PATTERN = /(^|[^a-z0-9])claude-(?:fable|mythos)-5(?![a-z0-9])/i;
+const CLAUDE_MYTHOS_PREVIEW_RE = /(^|[^a-z0-9])claude-mythos-preview(?![a-z0-9])/i;
+const CLAUDE_FABLE_MYTHOS_51_PATTERN = /(^|[^a-z0-9])claude-(?:fable|mythos)-5-1(?![a-z0-9])/i;
+const CLAUDE_OPUS_55_PATTERN = /(^|[^a-z0-9])claude-opus-5-5(?![a-z0-9])/i;
+const CLAUDE_OPUS_5_PATTERN = /(^|[^a-z0-9])claude-opus-5(?!-[0-9](?![0-9]))(?![a-z0-9])/i;
+const CLAUDE_SONNET_55_PATTERN = /(^|[^a-z0-9])claude-sonnet-5-5(?![a-z0-9])/i;
+const CLAUDE_SONNET_5_PATTERN = /(^|[^a-z0-9])claude-sonnet-5(?!-[0-9](?![0-9]))(?![a-z0-9])/i;
+const CLAUDE_OPUS_48_PATTERN = /(^|[^a-z0-9])claude-opus-4-8(?![0-9])/i;
+const CLAUDE_OPUS_47_PATTERN = /(^|[^a-z0-9])claude-opus-4-7(?![0-9])/i;
+const CLAUDE_5_OR_LATER_PATTERN = /(^|[^a-z0-9])claude-[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*){0,4}-(?:[5-9]|[1-9][0-9])(?![a-z0-9])/i;
+/**
+* Single source of truth for Claude model capabilities. Adding a model is a new row here
+* (plus, if a provider branches on it by name, a thin `isClaude<Model>Model` accessor)
+* instead of editing several parallel OR-chains. Regional-premium coverage follows
+* Anthropic's "Claude 4.5 models and beyond" pricing (Sonnet 4.5, Haiku 4.5, Opus 4.5, and
+* every later model); Opus 4.1 and earlier retain base pricing on all endpoints.
+*/
+const CLAUDE_MODEL_FAMILIES = [
+	{
+		match: CLAUDE_MYTHOS_PREVIEW_RE,
+		warningName: "Claude Mythos Preview",
+		samplingParamsDeprecated: true,
+		alwaysOnAdaptiveThinking: true
+	},
+	{
+		match: CLAUDE_FABLE_MYTHOS_51_PATTERN,
+		warningName: "Claude Fable 5.1 and Claude Mythos 5.1",
+		samplingParamsDeprecated: true,
+		alwaysOnAdaptiveThinking: true,
+		forcedToolChoiceUnsupported: true,
+		regionalPremium: true,
+		cacheReadMultiplier: .025
+	},
+	{
+		match: CLAUDE_FABLE_MYTHOS_5_PATTERN,
+		warningName: "Claude Fable 5 and Claude Mythos 5",
+		samplingParamsDeprecated: true,
+		alwaysOnAdaptiveThinking: true,
+		regionalPremium: true
+	},
+	{
+		match: CLAUDE_OPUS_55_PATTERN,
+		warningName: "Claude Opus 5.5",
+		samplingParamsDeprecated: true,
+		alwaysOnAdaptiveThinking: true,
+		forcedToolChoiceUnsupported: true,
+		regionalPremium: true,
+		cacheReadMultiplier: .05
+	},
+	{
+		match: CLAUDE_OPUS_5_PATTERN,
+		warningName: "Claude Opus 5",
+		samplingParamsDeprecated: true,
+		thinkingOnByDefault: true,
+		disabledThinkingEffortCapped: true,
+		regionalPremium: true
+	},
+	{
+		match: CLAUDE_SONNET_55_PATTERN,
+		warningName: "Claude Sonnet 5.5",
+		samplingParamsDeprecated: true,
+		thinkingOnByDefault: true,
+		disabledThinkingEffortCapped: true,
+		betweenToolsReplacesDisabledThinking: true,
+		forcedToolChoiceUnsupported: true,
+		regionalPremium: true
+	},
+	{
+		match: CLAUDE_SONNET_5_PATTERN,
+		warningName: "Claude Sonnet 5",
+		samplingParamsDeprecated: true,
+		thinkingOnByDefault: true,
+		regionalPremium: true
+	},
+	{
+		match: CLAUDE_OPUS_48_PATTERN,
+		warningName: "Claude Opus 4.7 and 4.8",
+		samplingParamsDeprecated: true,
+		regionalPremium: true
+	},
+	{
+		match: CLAUDE_OPUS_47_PATTERN,
+		warningName: "Claude Opus 4.7 and 4.8",
+		samplingParamsDeprecated: true,
+		regionalPremium: true
+	},
+	{
+		match: /(^|[^a-z0-9])claude-(?:opus|sonnet|haiku)-4-(?:5|6)(?![0-9])/i,
+		regionalPremium: true
+	}
+];
+function hasClaudeCapability(modelId, capability) {
+	return CLAUDE_MODEL_FAMILIES.some((family) => family[capability] && family.match.test(modelId));
+}
+/** Matches Claude Opus 5.5 model IDs. */
+function isClaudeOpus55Model(modelId) {
+	return CLAUDE_OPUS_55_PATTERN.test(modelId);
+}
+/** Matches Claude Opus 5 model IDs (not `claude-opus-4-5`, `-5-5`, or `-50`). */
+function isClaudeOpus5Model(modelId) {
+	return CLAUDE_OPUS_5_PATTERN.test(modelId);
+}
+/** Matches the Claude 5 Fable and Mythos model IDs. */
+function isClaudeFableOrMythos5Model(modelId) {
+	return CLAUDE_FABLE_MYTHOS_5_PATTERN.test(modelId);
+}
+/** Matches Claude Sonnet 5.5 model IDs. */
+function isClaudeSonnet55Model(modelId) {
+	return CLAUDE_SONNET_55_PATTERN.test(modelId);
+}
+/** Matches Claude Sonnet 5 model IDs (not `claude-sonnet-4-5`, `-5-5`, or `-50`). */
+function isClaudeSonnet5Model(modelId) {
+	return CLAUDE_SONNET_5_PATTERN.test(modelId);
+}
+function isForcedToolChoiceUnsupportedClaudeModel(modelId) {
+	return hasClaudeCapability(modelId, "forcedToolChoiceUnsupported");
+}
+/**
+* Name for a model in user-facing deprecation warnings, or `undefined` when it is not a
+* recognized family (callers fall back to a generic phrase).
+*/
+function getClaudeModelWarningName(modelId) {
+	return CLAUDE_MODEL_FAMILIES.find((family) => family.warningName && family.match.test(modelId))?.warningName;
+}
+/**
+* Claude models that carry a 10% premium on Bedrock regional and Vertex regional/multi-region
+* endpoints (vs the global endpoint), per Anthropic's "Claude 4.5 models and beyond" pricing.
+*/
+function isClaudeRegionalPremiumModel(modelId) {
+	return hasClaudeCapability(modelId, "regionalPremium");
+}
+function isAlwaysOnAdaptiveThinkingClaudeModel(modelId) {
+	return hasClaudeCapability(modelId, "alwaysOnAdaptiveThinking");
+}
+/** True when `between_tools`, not `disabled`, is the model's lowest thinking setting. */
+function isBetweenToolsLowestThinkingClaudeModel(modelId) {
+	return hasClaudeCapability(modelId, "betweenToolsReplacesDisabledThinking");
+}
+/**
+* True when omitting `thinking` still runs adaptive thinking (Claude Opus 5 / Sonnet 5). Callers use this
+* so that thinking-token headroom (e.g. the default `max_tokens`) reflects what the API will
+* actually do rather than assuming an absent `thinking` field means thinking is off.
+*/
+function isThinkingOnByDefaultClaudeModel(modelId) {
+	return hasClaudeCapability(modelId, "thinkingOnByDefault");
+}
+/**
+* Whether a request will spend output tokens on thinking, given the thinking config as
+* normalized by {@link normalizeClaudeThinkingConfig}. Thinking shares the `max_tokens`
+* budget with the answer, so providers size their default `max_tokens` off this — get it
+* wrong and responses truncate mid-answer.
+*
+* Note this is deliberately NOT the same question as "is thinking enabled". A model that
+* thinks by default consumes tokens without the request ever saying so, but must not be
+* treated as explicitly-enabled thinking: that would trigger the legacy extended-thinking
+* incompatibilities (forced `tool_choice` suppression, `top_p` clamping) which do not apply
+* to adaptive thinking. Callers that need that second question keep their own predicate.
+*/
+function claudeThinkingConsumesTokens(modelId, resolvedThinking) {
+	return isAlwaysOnAdaptiveThinkingClaudeModel(modelId) || resolvedThinking?.type === "enabled" || resolvedThinking?.type === "adaptive" || resolvedThinking == null && isThinkingOnByDefaultClaudeModel(modelId);
+}
+/**
+* True when the request cannot turn thinking off at this effort level. Claude Opus 5 only
+* accepts `disabled` at effort `high` or below, and Claude Sonnet 5.5 its `between_tools`
+* replacement, so either with `xhigh`/`max` is a 400. An unset effort uses the API default
+* (`high`), which is within the cap.
+*/
+function isDisabledThinkingRejectedAtEffort(modelId, effort) {
+	return hasClaudeCapability(modelId, "disabledThinkingEffortCapped") && (effort === "xhigh" || effort === "max");
+}
+/**
+* Whether a bare Anthropic model id has the shape of a Claude model.
+*
+* Used by the `anthropic:<model>` shorthand so a model released after this build still
+* resolves instead of being rejected at config load. Anthropic is the authority on which
+* ids exist and returns a clear `not_found_error` for one that does not, so gating the
+* shorthand on a local catalog only delays that answer to the next promptfoo release.
+*
+* The shape check is what keeps a genuine typo (`anthropic:sonnet-5`) failing at config
+* load with the usage message, rather than surfacing as a request-time 404.
+*/
+function looksLikeClaudeModelId(modelId) {
+	return /^claude-[a-z0-9]/i.test(modelId);
+}
+/**
+* Raise `max_tokens` above a manual thinking budget.
+*
+* Anthropic rejects any request where `max_tokens <= thinking.budget_tokens` with
+* "`max_tokens` must be greater than `thinking.budget_tokens`" — thinking draws from the
+* same output budget as the answer, so a budget at or above the cap leaves no room to reply.
+* The rule is the API's, not a platform's, so every Claude route needs it: a user who sets
+* `thinking: { type: 'enabled', budget_tokens: 8000 }` and leaves `max_tokens` at the
+* provider default otherwise gets a 400 rather than a longer think.
+*
+* Headroom of 1024 above the budget matches what the Vertex path has always used. Callers
+* keep their own `max_tokens` defaults, which legitimately differ per platform; this only
+* enforces the floor.
+*/
+function clampMaxTokensForThinkingBudget(maxTokens, thinking) {
+	if (thinking?.type !== "enabled" || !thinking.budget_tokens) return maxTokens;
+	return maxTokens <= thinking.budget_tokens ? thinking.budget_tokens + 1024 : maxTokens;
+}
+function normalizeAnthropicModelName(modelName) {
+	return modelName.replace(/^(?:(?:global|us|eu|jp|au)\.)?anthropic\./, "");
+}
+/**
+* Claude Opus 4.7/4.8 and Claude 5+ models deprecate manual sampling controls at the model
+* level — `temperature`, `top_p`, and `top_k` return 400 `invalid_request_error` (including
+* promptfoo's built-in `temperature` default of 0). Shared by the Anthropic, Bedrock, Vertex,
+* and Azure providers. Known families use the capability table above; the generation fallback
+* keeps newly released Claude 5+ family names safe before their model-specific rows land.
+* Arbitrary deployment and inference-profile aliases cannot safely use the fallback.
+*/
+function isSamplingParamsDeprecatedClaudeModel(modelId, options = {}) {
+	const isApplicationInferenceProfileArn = modelId.startsWith("arn:") && modelId.includes(":application-inference-profile/");
+	return hasClaudeCapability(modelId, "samplingParamsDeprecated") || options.allowGenerationFallback !== false && !isApplicationInferenceProfileArn && CLAUDE_5_OR_LATER_PATTERN.test(modelId);
+}
+/** Whether a Claude thinking config turns extended thinking on. */
+function isClaudeThinkingEnabled(thinking) {
+	return thinking?.type === "enabled" || thinking?.type === "adaptive";
+}
+/**
+* The sampling controls Claude accepts for one request, shared by every provider that sends
+* Claude a Messages body (Anthropic, Vertex, Bedrock). Claude rejects `temperature` together
+* with `top_p`; with thinking on it rejects `temperature` and `top_k` and needs `top_p` of at
+* least 0.95; models that deprecate sampling reject all three. `defaultTemperature` fills in
+* only where a temperature is allowed. Returns what to send and a warning per dropped value.
+*/
+function resolveClaudeSamplingParams({ temperature, top_p, top_k }, { thinkingEnabled, samplingParamsDeprecated, defaultTemperature }) {
+	if (samplingParamsDeprecated) return {
+		sampling: {},
+		warnings: []
+	};
+	const warnings = [];
+	if (thinkingEnabled) {
+		if (top_k != null) warnings.push("top_k is incompatible with extended thinking and will be omitted. Remove top_k from your config or disable thinking.");
+		if (temperature != null) warnings.push("temperature is incompatible with extended thinking and will be omitted. Remove temperature from your config or disable thinking.");
+		if (top_p == null) return {
+			sampling: {},
+			warnings
+		};
+		if (top_p < .95 || top_p > 1) warnings.push(`top_p must be between 0.95 and 1.0 with extended thinking (got ${top_p}). Clamping to valid range.`);
+		return {
+			sampling: { top_p: Math.max(.95, Math.min(1, top_p)) },
+			warnings
+		};
+	}
+	if (top_p != null && temperature != null) warnings.push("temperature is incompatible with top_p on Claude and will be omitted. Remove one of these parameters.");
+	const resolvedTemperature = top_p == null ? temperature ?? defaultTemperature : void 0;
+	return {
+		sampling: {
+			...resolvedTemperature == null ? {} : { temperature: resolvedTemperature },
+			...top_p == null ? {} : { top_p },
+			...top_k == null ? {} : { top_k }
+		},
+		warnings
+	};
+}
+/**
+* Normalize a Claude thinking config for models that deprecate manual
+* budget-based thinking: an `enabled` budget converts to adaptive thinking
+* (preserving `display`), and `disabled` is omitted on always-on adaptive
+* thinking models (Fable 5 / Mythos 5), which reject it. `disabled` is also
+* omitted on effort-capped models (Opus 5, Sonnet 5.5) when `effort` is high
+* enough that turning thinking off would 400, and otherwise becomes
+* `between_tools` on models that use it in place of `disabled` (Sonnet 5.5).
+* An explicit `between_tools` is omitted above that effort cap too.
+* The Anthropic, Bedrock InvokeModel/Converse, and Vertex paths all share this
+* transform; user-facing warnings stay at the call sites that surface them.
+*/
+function normalizeClaudeThinkingConfig(modelId, thinking, effort, options = {}) {
+	if (thinking?.type === "enabled" && (isSamplingParamsDeprecatedClaudeModel(modelId, options) || isAlwaysOnAdaptiveThinkingClaudeModel(modelId))) return {
+		type: "adaptive",
+		...thinking.display ? { display: thinking.display } : {}
+	};
+	if (thinking?.type === "disabled") {
+		if (isAlwaysOnAdaptiveThinkingClaudeModel(modelId) || isDisabledThinkingRejectedAtEffort(modelId, effort)) return;
+		if (isBetweenToolsLowestThinkingClaudeModel(modelId)) return { type: "between_tools" };
+	}
+	if (thinking?.type === "between_tools" && isBetweenToolsLowestThinkingClaudeModel(modelId) && isDisabledThinkingRejectedAtEffort(modelId, effort)) return;
+	return thinking;
+}
+const CLAUDE_REGIONAL_ENDPOINT_PREMIUM = 1.1;
+const CLAUDE_US_INFERENCE_GEO_MULTIPLIER = 1.1;
+const CLAUDE_46_OR_LATER_MODEL_PATTERN = /^claude-(?:(?:opus|sonnet)-4-(?:6|7|8)(?:-|$)|(?:fable|mythos|opus|sonnet)-5(?:-|$))/;
+/**
+* Mark a cost config for the Claude regional endpoint premium (see isClaudeRegionalPremiumModel),
+* unless the user supplied an explicit `cost`/`inputCost`/`outputCost` override. The premium is a
+* flat multiplier that calculateAnthropicCost applies to the *final* computed cost, so it composes
+* with provider-selected long-context and cache pricing rather than overriding either. Callers
+* decide whether the request is regional.
+*/
+function applyClaudeRegionalPremium(modelName, config) {
+	if (!isClaudeRegionalPremiumModel(modelName) || config.cost != null || config.inputCost != null || config.outputCost != null) return config;
+	return {
+		...config,
+		regionalPremiumMultiplier: CLAUDE_REGIONAL_ENDPOINT_PREMIUM
+	};
+}
+function getFileReferences(block) {
+	if (block.type === "container_upload") return [{
+		type: block.type,
+		file_id: block.file_id
+	}];
+	if ((block.type === "code_execution_tool_result" || block.type === "bash_code_execution_tool_result") && "content" in block.content) return block.content.content.map(({ type, file_id }) => ({
+		type,
+		file_id
+	}));
+	return [];
+}
+function outputFromMessage(message, showThinking) {
+	const segments = [];
+	let previousBlockWasText = false;
+	for (const block of message.content) {
+		if (block.type === "text") {
+			if (previousBlockWasText) segments[segments.length - 1] += block.text;
+			else segments.push(block.text);
+			previousBlockWasText = true;
+			continue;
+		}
+		previousBlockWasText = false;
+		if (block.type === "thinking" && showThinking && block.thinking.trim() !== "") segments.push(`Thinking: ${block.thinking}\nSignature: ${block.signature}`);
+		else if (block.type === "redacted_thinking" && showThinking) segments.push(`Redacted Thinking: ${block.data}`);
+		else if (block.type === "tool_use" || message.stop_reason === "pause_turn" && block.type !== "thinking" && block.type !== "redacted_thinking") segments.push(JSON.stringify(block));
+		else for (const file of getFileReferences(block)) segments.push(JSON.stringify(file));
+	}
+	return segments.filter((segment) => segment !== "").join("\n\n");
+}
+/**
+* Automatically extracts base64 data from data URLs for Anthropic image content.
+* This ensures compatibility with our universal data URL generation without requiring
+* users to modify their prompt templates with Nunjucks filters.
+*/
+function processAnthropicImageContent(content) {
+	return content.map((item) => {
+		if (item.type === "image" && item.source && item.source.type === "base64") {
+			const parsed = parseDataUrl(item.source.data);
+			if (parsed) return {
+				...item,
+				source: {
+					...item.source,
+					media_type: item.source.media_type || parsed.mimeType,
+					data: parsed.base64Data
+				}
+			};
+		}
+		return item;
+	});
+}
+function parseMessages(messages) {
+	try {
+		const parsed = JSON.parse(messages);
+		if (Array.isArray(parsed)) {
+			const systemMessage = parsed.find((msg) => msg.role === "system");
+			const thinking = parsed.find((msg) => msg.thinking)?.thinking;
+			return {
+				extractedMessages: parsed.filter((msg) => msg.role && msg.role !== "system").map((msg) => ({
+					role: msg.role,
+					content: Array.isArray(msg.content) ? processAnthropicImageContent(msg.content) : [{
+						type: "text",
+						text: msg.content
+					}]
+				})),
+				system: systemMessage ? Array.isArray(systemMessage.content) ? systemMessage.content : [{
+					type: "text",
+					text: systemMessage.content
+				}] : void 0,
+				thinking
+			};
+		}
+	} catch {}
+	const lines = messages.split("\n").map((line) => line.trim()).filter((line) => line);
+	let system;
+	let thinking;
+	const extractedMessages = [];
+	let currentRole = null;
+	let currentContent = [];
+	const pushMessage = () => {
+		if (currentRole && currentContent.length > 0) {
+			extractedMessages.push({
+				role: currentRole,
+				content: [{
+					type: "text",
+					text: currentContent.join("\n")
+				}]
+			});
+			currentContent = [];
+		}
+	};
+	for (const line of lines) if (line.startsWith("system:")) system = [{
+		type: "text",
+		text: line.slice(7).trim()
+	}];
+	else if (line.startsWith("thinking:")) try {
+		thinking = JSON.parse(line.slice(9).trim());
+	} catch {}
+	else if (line.startsWith("user:") || line.startsWith("assistant:")) {
+		pushMessage();
+		currentRole = line.startsWith("user:") ? "user" : "assistant";
+		currentContent.push(line.slice(line.indexOf(":") + 1).trim());
+	} else if (currentRole) currentContent.push(line);
+	else {
+		currentRole = "user";
+		currentContent.push(line);
+	}
+	pushMessage();
+	if (extractedMessages.length === 0 && !system) extractedMessages.push({
+		role: "user",
+		content: [{
+			type: "text",
+			text: messages.trim()
+		}]
+	});
+	return {
+		system,
+		extractedMessages,
+		thinking
+	};
+}
+/**
+* Compute input cost with Anthropic cache pricing applied.
+* Anthropic docs: input_tokens is the non-cached portion; cache_read and cache_creation are additive.
+* Cache read rates come from the model family. Five-minute cache writes cost
+* 125% of the base input rate; one-hour writes cost 200%.
+*/
+function calculateCacheInputCost(baseInputRate, uncachedInputTokens, cacheRead, cacheCreation, modelId = "", cacheCreation1h = 0) {
+	const cacheReadMultiplier = CLAUDE_MODEL_FAMILIES.find((family) => family.cacheReadMultiplier !== void 0 && family.match.test(modelId))?.cacheReadMultiplier ?? .1;
+	const oneHourCacheCreation = Math.min(Math.max(cacheCreation1h, 0), cacheCreation);
+	const fiveMinuteCacheCreation = Math.max(cacheCreation - oneHourCacheCreation, 0);
+	return uncachedInputTokens * baseInputRate + cacheRead * baseInputRate * cacheReadMultiplier + fiveMinuteCacheCreation * baseInputRate * 1.25 + oneHourCacheCreation * baseInputRate * 2;
+}
+function calculateAnthropicCost(modelName, config, promptTokens, completionTokens, cacheReadTokens, cacheCreationTokens, cacheCreation1hTokens, reportedInferenceGeo) {
+	const pricingModelName = normalizeAnthropicModelName(modelName);
+	const hasExplicitPricing = config.cost != null || config.inputCost != null || config.outputCost != null;
+	const registeredModel = ANTHROPIC_MODELS.find((model) => model.id === pricingModelName) ?? (hasExplicitPricing ? ANTHROPIC_COMPATIBILITY_ALIAS_MODELS.find((model) => model.id === pricingModelName) : void 0);
+	const modelInfo = pricingModelName !== modelName && pricingModelName === "claude-sonnet-5" ? {
+		id: pricingModelName,
+		cost: {
+			input: 3 / 1e6,
+			output: 15 / 1e6
+		}
+	} : registeredModel;
+	const effectiveConfig = pricingModelName !== modelName && !modelName.startsWith("global.") ? applyClaudeRegionalPremium(modelName, config) : config;
+	const regionalPremiumMultiplier = effectiveConfig.regionalPremiumMultiplier ?? 1;
+	const inferenceGeo = reportedInferenceGeo ?? effectiveConfig?.extra_body?.inference_geo;
+	const inferenceGeoMultiplier = pricingModelName === modelName && inferenceGeo === "us" && CLAUDE_46_OR_LATER_MODEL_PATTERN.test(pricingModelName) && effectiveConfig.cost == null && effectiveConfig.inputCost == null && effectiveConfig.outputCost == null ? CLAUDE_US_INFERENCE_GEO_MULTIPLIER : 1;
+	const withPricingMultipliers = (cost) => cost == null ? cost : cost * regionalPremiumMultiplier * inferenceGeoMultiplier;
+	const usesFlatCost = effectiveConfig.cost != null && effectiveConfig.inputCost == null && effectiveConfig.outputCost == null;
+	const cacheRead = cacheReadTokens ?? 0;
+	const cacheCreation = cacheCreationTokens ?? 0;
+	const cacheCreation1h = cacheCreation1hTokens ?? 0;
+	if (!usesFlatCost && modelInfo && (cacheRead || cacheCreation) && typeof promptTokens !== "undefined" && typeof completionTokens !== "undefined" && Number.isFinite(promptTokens) && Number.isFinite(completionTokens)) {
+		const inputCost = effectiveConfig.inputCost ?? effectiveConfig.cost ?? modelInfo.cost.input;
+		const outputCost = effectiveConfig.outputCost ?? effectiveConfig.cost ?? modelInfo.cost.output;
+		return withPricingMultipliers(calculateCacheInputCost(inputCost, promptTokens, cacheRead, cacheCreation, pricingModelName, cacheCreation1h) + completionTokens * outputCost);
+	}
+	return withPricingMultipliers(calculateCost(pricingModelName, effectiveConfig, promptTokens, completionTokens, modelInfo ? [modelInfo] : []));
+}
+/**
+* Extract refusal details from the Anthropic stop_details field.
+* Returns a human-readable string if the response was refused, or undefined otherwise.
+*/
+function getRefusalDetails(data) {
+	if (data.stop_reason !== "refusal" || !data.stop_details) return;
+	const details = data.stop_details;
+	const parts = ["Content refused by Anthropic safety filters"];
+	if (details.category) parts.push(`category: ${details.category}`);
+	if (details.explanation) parts.push(`explanation: ${details.explanation}`);
+	return parts.join(" — ");
+}
+/**
+* Coerce a token count that may arrive as a numeric string.
+*
+* Bedrock's InvokeModel responses have been observed serializing counts as strings, and
+* plain `?? 0` would make the sums below concatenate rather than add ("15" + 0 -> "150").
+*/
+function toTokenCount(value) {
+	const parsed = typeof value === "string" ? Number(value) : value;
+	return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : 0;
+}
+function getTokenUsage(data, cached) {
+	if (data.usage) {
+		const cacheRead = toTokenCount(data.usage.cache_read_input_tokens);
+		const cacheCreation = toTokenCount(data.usage.cache_creation_input_tokens);
+		const allInputTokens = toTokenCount(data.usage.input_tokens) + cacheRead + cacheCreation;
+		const total_tokens = allInputTokens + toTokenCount(data.usage.output_tokens);
+		if (cached) return {
+			cached: total_tokens,
+			total: total_tokens
+		};
+		else {
+			const usage = {
+				total: total_tokens,
+				prompt: allInputTokens,
+				completion: toTokenCount(data.usage.output_tokens)
+			};
+			const thinkingTokens = data.usage.output_tokens_details?.thinking_tokens;
+			const hasCacheDetails = data.usage.cache_read_input_tokens != null || data.usage.cache_creation_input_tokens != null;
+			if (thinkingTokens != null || hasCacheDetails) usage.completionDetails = {
+				...thinkingTokens != null && { reasoning: toTokenCount(thinkingTokens) },
+				...hasCacheDetails && {
+					cacheReadInputTokens: cacheRead,
+					cacheCreationInputTokens: cacheCreation
+				}
+			};
+			return usage;
+		}
+	}
+	return {};
+}
+const WEB_FETCH_FIELDS = [
+	"allowed_callers",
+	"max_uses",
+	"allowed_domains",
+	"blocked_domains",
+	"citations",
+	"max_content_tokens",
+	"cache_control",
+	"defer_loading",
+	"strict",
+	"url_sources"
+];
+const WEB_FETCH_20260309_FIELDS = [...WEB_FETCH_FIELDS, "use_cache"];
+const WEB_FETCH_20260318_FIELDS = [...WEB_FETCH_20260309_FIELDS, "response_inclusion"];
+const WEB_SEARCH_FIELDS = [
+	"allowed_callers",
+	"allowed_domains",
+	"blocked_domains",
+	"cache_control",
+	"defer_loading",
+	"max_uses",
+	"strict",
+	"user_location"
+];
+const WEB_SEARCH_20260318_FIELDS = [...WEB_SEARCH_FIELDS, "response_inclusion"];
+/**
+* Anthropic server tools promptfoo rebuilds from config, keyed by tool `type`.
+*
+* A Map rather than an object literal so a config with a prototype-shaped `type`
+* (`constructor`, `toString`, `__proto__`, …) misses cleanly and falls through to
+* pass-through, instead of resolving to an Object.prototype member and throwing.
+*/
+const SERVER_TOOL_SPECS = /* @__PURE__ */ new Map([
+	["web_fetch_20250910", {
+		name: "web_fetch",
+		fields: WEB_FETCH_FIELDS,
+		betaFeature: "web-fetch-2025-09-10"
+	}],
+	["web_fetch_20260209", {
+		name: "web_fetch",
+		fields: WEB_FETCH_FIELDS
+	}],
+	["web_fetch_20260309", {
+		name: "web_fetch",
+		fields: WEB_FETCH_20260309_FIELDS
+	}],
+	["web_fetch_20260318", {
+		name: "web_fetch",
+		fields: WEB_FETCH_20260318_FIELDS
+	}],
+	["web_search_20250305", {
+		name: "web_search",
+		fields: WEB_SEARCH_FIELDS
+	}],
+	["web_search_20260209", {
+		name: "web_search",
+		fields: WEB_SEARCH_FIELDS
+	}],
+	["web_search_20260318", {
+		name: "web_search",
+		fields: WEB_SEARCH_20260318_FIELDS
+	}]
+]);
+/**
+* Processes tools configuration to handle web fetch and web search tools
+*/
+function processAnthropicTools(tools = []) {
+	const processedTools = [];
+	const requiredBetaFeatures = [];
+	const addRequiredBetaFeature = (feature) => {
+		if (!requiredBetaFeatures.includes(feature)) requiredBetaFeatures.push(feature);
+	};
+	for (const tool of tools) {
+		const toolType = "type" in tool && typeof tool.type === "string" ? tool.type : void 0;
+		const spec = toolType === void 0 ? void 0 : SERVER_TOOL_SPECS.get(toolType);
+		if (spec) {
+			const source = tool;
+			const built = {
+				type: toolType,
+				name: spec.name
+			};
+			for (const field of spec.fields) {
+				const value = source[field];
+				if (value !== void 0) built[field] = value;
+			}
+			processedTools.push(built);
+			if (spec.betaFeature) addRequiredBetaFeature(spec.betaFeature);
+		} else processedTools.push(tool);
+		if ("strict" in tool && tool.strict === true) addRequiredBetaFeature("structured-outputs-2025-11-13");
+	}
+	return {
+		processedTools,
+		requiredBetaFeatures
+	};
+}
+function modelsWithCost(ids, cost) {
+	return ids.map((id) => ({
+		id,
+		cost: { ...cost }
+	}));
+}
+//#endregion
+export { parseMessages as A, isForcedToolChoiceUnsupportedClaudeModel as C, normalizeAnthropicModelName as D, looksLikeClaudeModelId as E, resolveClaudeSamplingParams as M, normalizeClaudeThinkingConfig as O, isDisabledThinkingRejectedAtEffort as S, isThinkingOnByDefaultClaudeModel as T, isClaudeOpus5Model as _, calculateAnthropicCost as a, isClaudeSonnet5Model as b, claudeThinkingConsumesTokens as c, getRefusalDetails as d, getTokenUsage as f, isClaudeOpus55Model as g, isClaudeFableOrMythos5Model as h, applyClaudeRegionalPremium as i, processAnthropicTools as j, outputFromMessage as k, getClaudeModelWarningName as l, isBetweenToolsLowestThinkingClaudeModel as m, ANTHROPIC_SHORTHAND_MODEL_IDS as n, calculateCacheInputCost as o, isAlwaysOnAdaptiveThinkingClaudeModel as p, CLAUDE_REGIONAL_ENDPOINT_PREMIUM as r, clampMaxTokensForThinkingBudget as s, ANTHROPIC_MODELS as t, getFileReferences as u, isClaudeRegionalPremiumModel as v, isSamplingParamsDeprecatedClaudeModel as w, isClaudeThinkingEnabled as x, isClaudeSonnet55Model as y };
+
+//# sourceMappingURL=util-LEbeiYw_.js.map