promptfoo 0.125.0 → 0.125.1

package/dist/src/messages-Cv_m6kYs.cjs

@@ -0,0 +1,1161 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+require("./dataUrl-BdHUey2l.cjs");
+const require_shared = require("./shared-D9Bf3UgD.cjs");
+const require_file = require("./file-CPfaem7U.cjs");
+const require_credentials = require("./credentials-CFfK32uY.cjs");
+const require_genaiTracer = require("./genaiTracer-C32xFIB8.cjs");
+const require_cache = require("./cache-iG87oYan.cjs");
+const require_util = require("./util-ClJRjlQA.cjs");
+const require_tokenUsageUtils = require("./tokenUsageUtils-DMF9uhT9.cjs");
+const require_finishReason = require("./finishReason-CqEQMOZJ.cjs");
+const require_transform = require("./transform-CPQu05u6.cjs");
+const require_session = require("./session-BksXvRH_.cjs");
+const require_util$1 = require("./util-CICwIpmu.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_crypto = require("node:crypto");
+let crypto = require("crypto");
+let node_child_process = require("node:child_process");
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = require_rolldown_runtime.__toESM(_anthropic_ai_sdk, 1);
+//#region src/providers/anthropic/claudeCodeAuth.ts
+/**
+* Claude Code prepends this identity block as the first `system` message when
+* calling the Anthropic Messages API with an OAuth token. As of 2025-Q4 the
+* API returns HTTP 400 `invalid_request_error` when an OAuth-authenticated
+* request's first system block is not this exact string, so any caller
+* reusing a Claude Code OAuth token must inject this block before the
+* user-provided system prompt. Re-verify if Anthropic ships an OAuth-native
+* `/v1/messages` path that drops the requirement.
+*/
+const CLAUDE_CODE_IDENTITY_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+/**
+* Anthropic beta headers required when authenticating the Messages API with a
+* Claude Code OAuth token (e.g. a Claude Max subscription access token, or a
+* long-lived token minted by `claude setup-token`).
+*
+* - `oauth-2025-04-20` enables OAuth bearer tokens on `/v1/messages`.
+* - `claude-code-20250219` enables the Claude Code tool-use surface area the
+*   OAuth token is scoped to.
+*
+* Revisit if Anthropic ships an OAuth-native Messages path that no longer
+* requires these betas.
+*/
+const CLAUDE_CODE_OAUTH_BETA_FEATURES = Object.freeze(["claude-code-20250219", "oauth-2025-04-20"]);
+/**
+* The `user-agent` value Claude Code CLI sends on OAuth-authenticated
+* Messages requests. Anthropic's API gates OAuth tokens to the Claude Code
+* app identity, so requests that use a different user-agent fail with 401.
+*
+* The semver is load-bearing too: newer models reject OAuth requests whose
+* `claude-cli` version predates the model's minimum client with 400
+* `invalid_request_error` (e.g. claude-opus-5-5 requires 2.1.280 or newer).
+* Keep this at a current CLI release and bump it alongside CLI updates.
+*/
+const CLAUDE_CODE_USER_AGENT = "claude-cli/2.1.285 (external, promptfoo)";
+const CLAUDE_CODE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+const CLAUDE_CODE_CREDENTIALS_FILENAME = ".credentials.json";
+/**
+* Returns the `CLAUDE_CONFIG_DIR` override when one is set, or `undefined`
+* for the default `~/.claude` layout. A provider-scoped `env` override takes
+* precedence over the root config / process environment, matching how other
+* provider env vars resolve (see `AnthropicGenericProvider.getApiKey`).
+*
+* The raw configured value is returned without path normalization on
+* purpose: the Claude Code CLI derives its macOS keychain service name from
+* the exact string (see {@link resolveKeychainService}), so normalizing here
+* would break keychain lookups for values with e.g. a trailing slash.
+*/
+function resolveConfiguredDir(env) {
+	return env?.CLAUDE_CONFIG_DIR || require_logger.getEnvString("CLAUDE_CONFIG_DIR") || void 0;
+}
+/**
+* Resolves the directory Claude Code stores its config (including
+* `.credentials.json`) in. Honors `CLAUDE_CONFIG_DIR`, the same environment
+* variable the Claude Code CLI itself uses to relocate `~/.claude`, so
+* Promptfoo finds the credential file when a user has customized their
+* Claude Code config location.
+*/
+function resolveConfigDir(env) {
+	return resolveConfiguredDir(env) ?? node_path.default.join(node_os.default.homedir(), ".claude");
+}
+function resolveCredentialsPath(env) {
+	return node_path.default.join(resolveConfigDir(env), CLAUDE_CODE_CREDENTIALS_FILENAME);
+}
+/**
+* Resolves the macOS keychain service name for the Claude Code credential,
+* mirroring the Claude Code CLI: with the default config dir it is
+* `Claude Code-credentials`, but whenever `CLAUDE_CONFIG_DIR` is set — even
+* to the default `~/.claude` — the CLI appends `-` plus the first 8 hex
+* chars of sha256 of the *raw* configured value (no path normalization; a
+* trailing slash produces a different hash). Empirically verified against
+* claude v2.1.204 by tracing its `security find-generic-password` calls;
+* this is an internal CLI detail that may drift, in which case the lookup
+* misses and falls through to the credentials-file path, then to the
+* caller's "no credential found" warning.
+*/
+function resolveKeychainService(env) {
+	const configuredDir = resolveConfiguredDir(env);
+	if (!configuredDir) return CLAUDE_CODE_KEYCHAIN_SERVICE;
+	const suffix = (0, node_crypto.createHash)("sha256").update(configuredDir).digest("hex").slice(0, 8);
+	return `${CLAUDE_CODE_KEYCHAIN_SERVICE}-${suffix}`;
+}
+/**
+* `security` exits with status 44 when the requested generic-password entry
+* does not exist. Any other non-zero exit (or throw) indicates a real failure
+* — ACL denial, corrupted entry, missing binary, timeout — and is worth a
+* `warn` log rather than silently falling through.
+*/
+const SECURITY_ENTRY_NOT_FOUND = 44;
+function parseCredential(raw) {
+	if (!raw || typeof raw !== "object") return {
+		ok: false,
+		reason: "credential JSON is not an object"
+	};
+	const claudeAiOauth = raw.claudeAiOauth;
+	if (!claudeAiOauth || typeof claudeAiOauth !== "object") return {
+		ok: false,
+		reason: "missing `claudeAiOauth` object"
+	};
+	const inner = claudeAiOauth;
+	const accessToken = inner.accessToken;
+	if (typeof accessToken !== "string" || !accessToken) return {
+		ok: false,
+		reason: "missing `claudeAiOauth.accessToken` string"
+	};
+	const credential = { accessToken };
+	if (typeof inner.refreshToken === "string" && inner.refreshToken) credential.refreshToken = inner.refreshToken;
+	if (typeof inner.expiresAt === "number" && Number.isFinite(inner.expiresAt)) credential.expiresAt = inner.expiresAt;
+	if (typeof inner.subscriptionType === "string") credential.subscriptionType = inner.subscriptionType;
+	return {
+		ok: true,
+		credential
+	};
+}
+function parseJsonBlob(blob) {
+	let parsed;
+	try {
+		parsed = JSON.parse(blob);
+	} catch (err) {
+		return {
+			ok: false,
+			reason: `invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	return parseCredential(parsed);
+}
+function readFromMacosKeychain(env) {
+	if (process.platform !== "darwin") return null;
+	let out;
+	try {
+		out = (0, node_child_process.execFileSync)("security", [
+			"find-generic-password",
+			"-s",
+			resolveKeychainService(env),
+			"-w"
+		], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 5e3
+		});
+	} catch (err) {
+		if (err?.status === SECURITY_ENTRY_NOT_FOUND) {
+			require_logger.logger.debug("[anthropic] No Claude Code credential entry in the macOS keychain; trying file fallback.");
+			return null;
+		}
+		require_logger.logger.warn("[anthropic] Failed to read Claude Code credential from macOS keychain; falling back to file lookup.", { error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+	const trimmed = out.trim();
+	if (!trimmed) {
+		require_logger.logger.warn("[anthropic] Claude Code macOS keychain entry is empty. Run `claude /login` to refresh it.");
+		return null;
+	}
+	const result = parseJsonBlob(trimmed);
+	if (!result.ok) {
+		require_logger.logger.warn(`[anthropic] Claude Code macOS keychain entry is malformed (${result.reason}). Run \`claude /login\` to refresh it.`);
+		return null;
+	}
+	return result.credential;
+}
+function readFromFile(env) {
+	const filePath = resolveCredentialsPath(env);
+	if (!node_fs.default.existsSync(filePath)) return null;
+	let raw;
+	try {
+		raw = node_fs.default.readFileSync(filePath, "utf-8");
+	} catch (err) {
+		require_logger.logger.warn(`[anthropic] Claude Code credentials file at ${filePath} exists but could not be read. Run \`claude /login\` to refresh it.`, { error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+	const result = parseJsonBlob(raw);
+	if (!result.ok) {
+		require_logger.logger.warn(`[anthropic] Claude Code credentials file at ${filePath} is malformed (${result.reason}). Run \`claude /login\` to refresh it.`);
+		return null;
+	}
+	return result.credential;
+}
+/**
+* Loads a Claude Code OAuth credential from the local environment.
+*
+* Resolution order:
+* 1. macOS keychain — only attempted on darwin. The service name mirrors the
+*    Claude Code CLI: `Claude Code-credentials` for the default config dir,
+*    or `Claude Code-credentials-<sha256(CLAUDE_CONFIG_DIR)[:8]>` when
+*    `CLAUDE_CONFIG_DIR` is set (see {@link resolveKeychainService}), so each
+*    Claude Code profile resolves to its own credential.
+* 2. `$HOME/.claude/.credentials.json` — the Linux/Windows default used by
+*    Claude Code, and a fallback on macOS when the keychain entry is missing.
+*    On Windows this resolves to `%USERPROFILE%\.claude\.credentials.json`.
+*    Set `CLAUDE_CONFIG_DIR` to read from a different directory instead —
+*    the same environment variable the Claude Code CLI itself uses to
+*    relocate `~/.claude`. It resolves from the provider-scoped `env`
+*    override first, then the root config / process environment.
+*
+* Returns `null` when no credential is available. Callers should check
+* {@link isCredentialExpired} on a non-null return before using it — this
+* function does not filter out expired credentials so callers can decide
+* whether to warn, refuse, or surface a 401 to the user.
+*
+* Never throws. Missing credentials fall through silently; corrupted or
+* unreadable credentials are logged at `warn` level with a reason so broken
+* setups are diagnosable without enabling debug logging.
+*/
+function loadClaudeCodeCredential(env) {
+	return readFromMacosKeychain(env) ?? readFromFile(env);
+}
+/**
+* Returns `true` when the credential's `expiresAt` (ms since epoch) is in the
+* past. Credentials without an `expiresAt` are treated as non-expired — the
+* Anthropic API will reject them with a 401 if the token is actually invalid.
+*/
+function isCredentialExpired(credential) {
+	if (credential.expiresAt == null) return false;
+	return Date.now() >= credential.expiresAt;
+}
+//#endregion
+//#region src/providers/anthropic/generic.ts
+function getScopedCustomHeaders(env) {
+	return require_logger.getExplicitProviderEnv(env)?.ANTHROPIC_CUSTOM_HEADERS ?? require_logger.getEnvOverrides("provider")?.ANTHROPIC_CUSTOM_HEADERS ?? env?.ANTHROPIC_CUSTOM_HEADERS ?? require_logger.getEnvOverrides()?.ANTHROPIC_CUSTOM_HEADERS ?? require_logger.getEnvOverrides("file")?.ANTHROPIC_CUSTOM_HEADERS;
+}
+/**
+* Parse ANTHROPIC_CUSTOM_HEADERS the same way the Anthropic SDK does
+* (newline-separated `Name: value` lines) and map each header name to null so
+* the SDK omits it. Providers that reuse the SDK against Anthropic-compatible
+* third-party endpoints use this to keep Anthropic-scoped headers (often
+* gateway/proxy secrets) off foreign hosts.
+*/
+function getAnthropicEnvHeaderSuppressions(env) {
+	const scopedHeaders = getScopedCustomHeaders(env);
+	return Object.fromEntries(Object.keys({
+		...parseAnthropicCustomHeaders(process.env.ANTHROPIC_CUSTOM_HEADERS),
+		...parseAnthropicCustomHeaders(scopedHeaders)
+	}).map((name) => [name, null]));
+}
+/**
+* Client options for an Anthropic-compatible endpoint that is *not* Anthropic
+* (Bedrock's mantle host, a Cloudflare AI Gateway).
+*
+* `ANTHROPIC_CUSTOM_HEADERS` is scoped to api.anthropic.com, so anything it
+* defines — an Authorization bearer, a proxy secret, an Anthropic `x-api-key` —
+* must never ride along to a third-party host. Drop every name it defines, in
+* every case variant (HTTP header names are case-insensitive, so `X-Api-Key`
+* and `x-api-key` are the same header and both have to go), then re-assert this
+* provider's own credential.
+*/
+function buildIsolatedAnthropicClientOptions(options, env, apiKey) {
+	const suppressedEnvHeaders = getAnthropicEnvHeaderSuppressions(env);
+	const suppressedNames = new Set(Object.keys(suppressedEnvHeaders).map((name) => name.toLowerCase()));
+	const safeDefaultHeaders = Object.fromEntries(Object.entries(options.defaultHeaders ?? {}).filter(([name]) => !suppressedNames.has(name.toLowerCase())));
+	const apiKeyHeaders = Object.fromEntries(Object.keys(suppressedEnvHeaders).filter((name) => name.toLowerCase() === "x-api-key").map((name) => [name, apiKey]));
+	return {
+		...options,
+		defaultHeaders: {
+			...safeDefaultHeaders,
+			...suppressedEnvHeaders,
+			...apiKey ? {
+				"x-api-key": apiKey,
+				...apiKeyHeaders
+			} : {}
+		}
+	};
+}
+function parseAnthropicCustomHeaders(value) {
+	const headers = {};
+	for (const line of value?.split("\n") ?? []) {
+		const colon = line.indexOf(":");
+		if (colon >= 0) {
+			const name = line.substring(0, colon).trim();
+			if (name) headers[name] = line.substring(colon + 1).trim();
+		}
+	}
+	return headers;
+}
+function setCaseInsensitiveHeaderValue(headers, headerName, value) {
+	headers[headerName] = value;
+	for (const name of Object.keys(headers)) if (name.toLowerCase() === headerName.toLowerCase()) headers[name] = value;
+}
+function getAnthropicCustomHeaderOverrides(env) {
+	const customHeaders = getScopedCustomHeaders(env);
+	if (customHeaders === void 0) return {};
+	return {
+		...getAnthropicEnvHeaderSuppressions(env),
+		...parseAnthropicCustomHeaders(customHeaders)
+	};
+}
+const ANTHROPIC_CACHE_HASH_CONTEXT = "promptfoo:anthropic:cache-key:v1";
+const MAX_EPHEMERAL_RESPONSE_CACHE_ENTRIES = 512;
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (isPlainObject(value)) {
+		const entries = Object.keys(value).sort().map((k) => [k, canonicalize(value[k])]);
+		return Object.fromEntries(entries);
+	}
+	return value;
+}
+function hashAnthropicCacheValue(value) {
+	const canonical = canonicalize(value);
+	const serialized = typeof canonical === "string" ? canonical : JSON.stringify(canonical) ?? String(canonical);
+	return (0, crypto.createHash)("sha256").update(ANTHROPIC_CACHE_HASH_CONTEXT).update("\0").update(serialized).digest("hex");
+}
+/**
+* Generic provider class for Anthropic APIs.
+*
+* Serves as a base class with shared functionality for all Anthropic
+* subclass providers. Handles API key resolution and, for subclasses that
+* opt in via {@link AnthropicGenericProvider.SUPPORTS_CLAUDE_CODE_OAUTH},
+* falls back to an OAuth token loaded from a local Claude Code session so
+* Claude.ai subscribers can run evals without a separate console API key.
+*
+* The OAuth fallback is opt-in so it only affects
+* `AnthropicMessagesProvider`. Claude Code OAuth tokens are gated to the
+* Messages API (`/v1/messages`) — forwarding them to the legacy
+* text-completion endpoint would fail at request time, which would cause
+* `anthropic:completion:*` configs to bypass promptfoo's upfront preflight
+* check and then produce a less useful error for every test case.
+*/
+var AnthropicGenericProvider = class {
+	/**
+	* Subclasses that can authenticate via a Claude Code OAuth session
+	* should override this to `true`. The base class's constructor reads the
+	* flag from `this.constructor` so only OAuth-capable subclasses attempt
+	* the credential lookup (and only they honor `apiKeyRequired: false`).
+	*/
+	static SUPPORTS_CLAUDE_CODE_OAUTH = false;
+	modelName;
+	config;
+	env;
+	apiKey;
+	/**
+	* `true` when this provider is authenticating via a Claude Code OAuth token
+	* rather than a standard `ANTHROPIC_API_KEY`. Subclasses use this to inject
+	* the Claude Code identity system block that Anthropic's API requires for
+	* OAuth-authenticated Messages requests.
+	*/
+	usingClaudeCodeOAuth;
+	/**
+	* The Claude Code credential used to authenticate, when
+	* `usingClaudeCodeOAuth` is `true`. Kept so subclasses can re-check expiry
+	* at request time and surface a "run `claude /login`" error instead of a
+	* raw 401 from the SDK.
+	*/
+	claudeCodeCredential;
+	anthropic;
+	label;
+	clientHasCustomHeaders;
+	ephemeralCacheNamespace = (0, crypto.randomUUID)();
+	ephemeralResponseCache = /* @__PURE__ */ new Map();
+	ephemeralCacheClearGeneration = 0;
+	constructor(modelName, options = {}) {
+		const { config, id, label, env } = options;
+		this.env = env;
+		this.modelName = modelName;
+		this.config = config || {};
+		this.label = label;
+		const customHeaders = getScopedCustomHeaders(this.env) ?? require_logger.getEnvString("ANTHROPIC_CUSTOM_HEADERS");
+		this.clientHasCustomHeaders = Object.keys(this.config.headers ?? {}).length > 0 || Object.keys(parseAnthropicCustomHeaders(customHeaders)).length > 0;
+		this.apiKey = this.getApiKey();
+		this.usingClaudeCodeOAuth = false;
+		let authToken;
+		const defaultHeaders = {};
+		const subclass = this.constructor;
+		if (!this.apiKey && this.config.apiKeyRequired === false && subclass.SUPPORTS_CLAUDE_CODE_OAUTH) {
+			const credential = loadClaudeCodeCredential(this.env);
+			if (credential) {
+				if (isCredentialExpired(credential)) require_logger.logger.warn("[anthropic] Claude Code OAuth credential is expired. Run `claude /login` to refresh it.");
+				else require_logger.logger.debug("[anthropic] Authenticating with Claude Code OAuth credential from local session.");
+				authToken = credential.accessToken;
+				this.usingClaudeCodeOAuth = true;
+				this.claudeCodeCredential = credential;
+				defaultHeaders["anthropic-beta"] = CLAUDE_CODE_OAUTH_BETA_FEATURES.join(",");
+				defaultHeaders["user-agent"] = CLAUDE_CODE_USER_AGENT;
+				defaultHeaders["x-app"] = "cli";
+			} else require_logger.logger.warn("[anthropic] apiKeyRequired is false but no Claude Code credential was found. Run `claude /login` to create one, or set ANTHROPIC_API_KEY.");
+		}
+		const clientDefaultHeaders = {
+			...getAnthropicCustomHeaderOverrides(this.env),
+			...defaultHeaders
+		};
+		const scopedCustomHeaderValue = getScopedCustomHeaders(this.env);
+		const scopedCustomHeaders = parseAnthropicCustomHeaders(scopedCustomHeaderValue);
+		const scopedAuthHeaders = new Set(Object.keys(scopedCustomHeaders).map((name) => name.toLowerCase()));
+		if (scopedCustomHeaderValue !== void 0 && this.apiKey && !scopedAuthHeaders.has("x-api-key")) setCaseInsensitiveHeaderValue(clientDefaultHeaders, "x-api-key", this.apiKey);
+		if (scopedCustomHeaderValue !== void 0 && authToken && !scopedAuthHeaders.has("authorization")) setCaseInsensitiveHeaderValue(clientDefaultHeaders, "authorization", `Bearer ${authToken}`);
+		this.anthropic = new _anthropic_ai_sdk.default(this.buildAnthropicClientOptions({
+			apiKey: this.apiKey ?? null,
+			authToken: authToken ?? null,
+			baseURL: this.getApiBaseUrl(),
+			...Object.keys(clientDefaultHeaders).length > 0 ? { defaultHeaders: clientDefaultHeaders } : {}
+		}));
+		this.id = id ? () => id : this.id;
+	}
+	/**
+	* Options for the Anthropic SDK client built during construction.
+	* Subclasses that point the SDK at an Anthropic-compatible third-party
+	* endpoint can override this to adjust auth or headers (e.g. bearer-token
+	* services). Called from the constructor, so overrides may only rely on
+	* `config`, `env`, and `apiKey`, which are set before the client is built.
+	*/
+	buildAnthropicClientOptions(options) {
+		return options;
+	}
+	id() {
+		return `anthropic:${this.modelName}`;
+	}
+	toString() {
+		return `[Anthropic Provider ${this.modelName}]`;
+	}
+	/**
+	* Whether promptfoo's preflight check should require an API key before
+	* dispatching requests to this provider. Returns `false` only for
+	* OAuth-capable subclasses (see {@link SUPPORTS_CLAUDE_CODE_OAUTH}) when
+	* the user has opted in via `apiKeyRequired: false`. All other subclasses
+	* keep the preflight check so missing-credential errors surface upfront
+	* rather than at per-request call time.
+	*/
+	requiresApiKey() {
+		if (this.constructor.SUPPORTS_CLAUDE_CODE_OAUTH && this.config.apiKeyRequired === false) return false;
+		return true;
+	}
+	getApiKey() {
+		return require_credentials.resolveProviderApiKey(this.config, this.env, ["ANTHROPIC_API_KEY"]);
+	}
+	getApiBaseUrl() {
+		const envUrl = require_logger.getProviderEnvString(this.env, "ANTHROPIC_BASE_URL") ?? require_logger.getEnvString("ANTHROPIC_BASE_URL");
+		return this.config?.apiBaseUrl || (envUrl === "" ? "https://api.anthropic.com" : envUrl);
+	}
+	getCacheIdentityHash() {
+		return hashAnthropicCacheValue({ apiBaseUrl: this.getApiBaseUrl() });
+	}
+	hasCustomHeaders() {
+		const customHeaders = getScopedCustomHeaders(this.env) ?? require_logger.getEnvString("ANTHROPIC_CUSTOM_HEADERS");
+		return this.clientHasCustomHeaders || Object.keys(parseAnthropicCustomHeaders(customHeaders)).length > 0;
+	}
+	getCacheNamespace() {
+		return hashAnthropicCacheValue({
+			providerId: this.id(),
+			providerLabel: this.label || this.ephemeralCacheNamespace
+		});
+	}
+	async getCachedResponse(cache, cacheKey, ephemeralCacheKey, clearGeneration) {
+		if (this.label) return cache.get(cacheKey);
+		this.syncEphemeralCache(clearGeneration);
+		const entry = this.ephemeralResponseCache.get(ephemeralCacheKey);
+		if (!entry) return;
+		if (entry.expiresAt <= Date.now()) {
+			this.ephemeralResponseCache.delete(ephemeralCacheKey);
+			return;
+		}
+		return entry.response;
+	}
+	async setCachedResponse(cache, cacheKey, ephemeralCacheKey, clearGeneration, ttlMs, response) {
+		if (this.label) {
+			await cache.set(cacheKey, response);
+			return;
+		}
+		this.syncEphemeralCache(clearGeneration);
+		if (!this.ephemeralResponseCache.has(ephemeralCacheKey) && this.ephemeralResponseCache.size >= MAX_EPHEMERAL_RESPONSE_CACHE_ENTRIES) {
+			const oldestKey = this.ephemeralResponseCache.keys().next().value;
+			if (oldestKey !== void 0) this.ephemeralResponseCache.delete(oldestKey);
+		}
+		this.ephemeralResponseCache.set(ephemeralCacheKey, {
+			response,
+			expiresAt: ttlMs <= 0 ? Number.POSITIVE_INFINITY : Date.now() + ttlMs
+		});
+	}
+	syncEphemeralCache(clearGeneration) {
+		if (this.ephemeralCacheClearGeneration !== clearGeneration) {
+			this.ephemeralResponseCache.clear();
+			this.ephemeralCacheClearGeneration = clearGeneration;
+		}
+	}
+	/**
+	* Base implementation - should be overridden by specific provider implementations
+	*/
+	async callApi(_prompt, _context) {
+		throw new Error("Not implemented: callApi must be implemented by subclasses");
+	}
+};
+//#endregion
+//#region src/providers/anthropic/messages.ts
+const DEFAULT_MAX_MCP_TOOL_CALLS = 8;
+const MAX_PAUSE_TURN_RESUMES = 5;
+async function finalMessageWithStreamedStopDetails(stream) {
+	let streamedStopDetails;
+	stream.on?.("streamEvent", (event) => {
+		if (event.type === "message_delta" && event.delta.stop_details != null) streamedStopDetails = event.delta.stop_details;
+	});
+	const finalMessage = await stream.finalMessage();
+	return finalMessage.stop_details == null && streamedStopDetails != null ? {
+		...finalMessage,
+		stop_details: streamedStopDetails
+	} : finalMessage;
+}
+function normalizeHeadersForCacheKey(headers) {
+	if (Object.keys(headers).length === 0) return;
+	return Object.entries(headers).map(([name, value]) => ({
+		name: name.toLowerCase(),
+		valueHash: hashAnthropicCacheValue(value)
+	})).sort((headerA, headerB) => {
+		const nameComparison = headerA.name.localeCompare(headerB.name);
+		return nameComparison === 0 ? headerA.valueHash.localeCompare(headerB.valueHash) : nameComparison;
+	});
+}
+function getMessagesRequestMetadata(params) {
+	const mcpServers = params.mcp_servers;
+	return {
+		model: params.model,
+		max_tokens: params.max_tokens,
+		messageCount: params.messages.length,
+		stream: params.stream,
+		temperature: params.temperature,
+		hasSystem: params.system !== void 0,
+		stopSequenceCount: Array.isArray(params.stop_sequences) ? params.stop_sequences.length : void 0,
+		thinkingEnabled: require_util$1.isClaudeThinkingEnabled(params.thinking),
+		toolCount: Array.isArray(params.tools) ? params.tools.length : void 0,
+		hasToolChoice: params.tool_choice !== void 0,
+		hasMetadata: params.metadata !== void 0,
+		hasMcpServers: Array.isArray(mcpServers) && mcpServers.length > 0,
+		hasOutputConfig: params.output_config !== void 0
+	};
+}
+function getMessagesResponseMetadata(response) {
+	return {
+		model: response.model,
+		type: response.type,
+		contentBlockCount: Array.isArray(response.content) ? response.content.length : void 0,
+		stopReason: response.stop_reason,
+		inputTokens: response.usage?.input_tokens,
+		outputTokens: response.usage?.output_tokens,
+		cacheReadInputTokens: response.usage?.cache_read_input_tokens,
+		cacheCreationInputTokens: response.usage?.cache_creation_input_tokens
+	};
+}
+function getMaxMcpToolCalls(config) {
+	if (config.max_tool_calls == null) return DEFAULT_MAX_MCP_TOOL_CALLS;
+	if (!Number.isFinite(config.max_tool_calls) || config.max_tool_calls < 0) return DEFAULT_MAX_MCP_TOOL_CALLS;
+	return Math.floor(config.max_tool_calls);
+}
+function getMcpContinuationParams(params, messages) {
+	if (params.tool_choice?.type === "any" || params.tool_choice?.type === "tool") {
+		const { tool_choice: _toolChoice, ...continuationParams } = params;
+		return {
+			...continuationParams,
+			messages
+		};
+	}
+	return {
+		...params,
+		messages
+	};
+}
+/** Reuse the turn's container unless the caller pinned a different one. */
+function withTurnContainer(params, responses) {
+	const requested = params.container;
+	if (typeof requested === "string" || requested?.id != null) return params;
+	for (let i = responses.length - 1; i >= 0; i--) {
+		const container = responses[i].container;
+		if (container) return {
+			...params,
+			container: requested ? {
+				...requested,
+				id: container.id
+			} : container.id
+		};
+	}
+	return params;
+}
+function coerceMcpToolInput(input) {
+	if (input == null || input === "") return {};
+	if (typeof input === "string") {
+		const parsed = JSON.parse(input);
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+	}
+	return typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+function mergeAnthropicUsage(messages) {
+	const usageEntries = messages.map((message) => message.usage).filter((usage) => usage != null);
+	if (usageEntries.length === 0) return;
+	const [firstUsage, ...remainingUsageEntries] = usageEntries;
+	return remainingUsageEntries.reduce((acc, usage) => ({
+		...usage,
+		input_tokens: acc.input_tokens + (usage.input_tokens ?? 0),
+		output_tokens: acc.output_tokens + (usage.output_tokens ?? 0),
+		cache_creation_input_tokens: (acc.cache_creation_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0),
+		cache_creation: acc.cache_creation || usage.cache_creation ? {
+			ephemeral_5m_input_tokens: (acc.cache_creation?.ephemeral_5m_input_tokens ?? 0) + (usage.cache_creation?.ephemeral_5m_input_tokens ?? 0),
+			ephemeral_1h_input_tokens: (acc.cache_creation?.ephemeral_1h_input_tokens ?? 0) + (usage.cache_creation?.ephemeral_1h_input_tokens ?? 0)
+		} : null,
+		cache_read_input_tokens: (acc.cache_read_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0),
+		output_tokens_details: acc.output_tokens_details || usage.output_tokens_details ? { thinking_tokens: (acc.output_tokens_details?.thinking_tokens ?? 0) + (usage.output_tokens_details?.thinking_tokens ?? 0) } : null
+	}), firstUsage);
+}
+function withMergedAnthropicUsage(response, responses) {
+	const usage = mergeAnthropicUsage(responses);
+	return usage ? {
+		...response,
+		usage
+	} : response;
+}
+function toCachedMessage(message, responses) {
+	if (responses.length === 1) return message;
+	return {
+		...message,
+		fileReferences: responses.flatMap((response) => response.content.flatMap(require_util$1.getFileReferences)),
+		finalText: responses[responses.length - 1].content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+		billedCalls: responses.map(({ stop_details, stop_reason, usage }) => ({
+			stop_details,
+			stop_reason,
+			usage
+		}))
+	};
+}
+var AnthropicMessagesProvider = class AnthropicMessagesProvider extends AnthropicGenericProvider {
+	calculateMessageCost(config, message, modelName = this.modelName) {
+		if (message.stop_reason === "refusal" && message.usage?.output_tokens === 0 && ![
+			"bio",
+			"frontier_llm",
+			"reasoning_extraction"
+		].includes(message.stop_details?.category ?? "")) return 0;
+		return require_util$1.calculateAnthropicCost(modelName, config, message.usage?.input_tokens, message.usage?.output_tokens, message.usage?.cache_read_input_tokens ?? void 0, message.usage?.cache_creation_input_tokens ?? void 0, message.usage?.cache_creation?.ephemeral_1h_input_tokens ?? void 0, message.usage?.inference_geo);
+	}
+	calculateMessageCosts(config, calls) {
+		return calls.reduce((total, call) => {
+			const callCost = this.calculateMessageCost(config, call);
+			return total != null && callCost != null ? total + callCost : void 0;
+		}, 0);
+	}
+	mcpClient = null;
+	mcpSession;
+	samplingParamsDeprecationWarned = false;
+	manualThinkingConversionWarned = false;
+	disabledThinkingRemovalWarned = false;
+	static SUPPORTS_CLAUDE_CODE_OAUTH = true;
+	static ANTHROPIC_MODELS = require_util$1.ANTHROPIC_MODELS;
+	static ANTHROPIC_MODELS_NAMES = require_util$1.ANTHROPIC_MODELS.map((model) => model.id);
+	static WARNS_ON_UNKNOWN_MODEL = true;
+	constructor(modelName, options = {}) {
+		super(modelName, options);
+		if (this.constructor.WARNS_ON_UNKNOWN_MODEL && !AnthropicMessagesProvider.ANTHROPIC_MODELS_NAMES.includes(require_util$1.normalizeAnthropicModelName(modelName))) require_logger.logger.warn(`Using unknown Anthropic model: ${modelName}`);
+		const { id } = options;
+		this.id = id ? () => id : this.id;
+		this.initializeMCP().catch(() => void 0);
+	}
+	async initializeMCP(signal) {
+		if (!this.config.mcp?.enabled) return;
+		this.mcpSession ??= new require_session.McpClientSession(this.config.mcp);
+		this.mcpClient = await this.mcpSession.initialize(signal);
+	}
+	async cleanup() {
+		try {
+			await this.mcpSession?.cleanup();
+		} finally {
+			this.mcpClient = this.mcpSession?.client ?? null;
+		}
+	}
+	/** Resume paused server-tool turns, retaining each request for usage and cost. */
+	async sendMessage(params, headers, shouldStream, responses, signal) {
+		const requestOptions = {
+			...Object.keys(headers).length > 0 && { headers },
+			...signal && { signal }
+		};
+		const send = async (requestParams) => {
+			signal?.throwIfAborted();
+			requestParams = withTurnContainer(requestParams, responses);
+			const message = shouldStream ? await finalMessageWithStreamedStopDetails(await this.anthropic.messages.stream(requestParams, requestOptions)) : await this.anthropic.messages.create(requestParams, requestOptions);
+			require_logger.logger.debug("Anthropic Messages API response", { response: getMessagesResponseMetadata(message) });
+			responses.push(message);
+			return message;
+		};
+		let message = await send(params);
+		if (message.stop_reason !== "pause_turn") return message;
+		let turnContent = message.content;
+		for (let resumes = 0; message.stop_reason === "pause_turn"; resumes++) {
+			if (resumes === MAX_PAUSE_TURN_RESUMES) {
+				require_logger.logger.warn(`Claude's turn was still paused (stop_reason: pause_turn) after ${MAX_PAUSE_TURN_RESUMES} resumes, so the output may be incomplete. Lower the tool max_uses or split the task.`);
+				break;
+			}
+			try {
+				message = await send({
+					...params,
+					messages: [...params.messages, {
+						role: "assistant",
+						content: turnContent
+					}]
+				});
+			} catch (err) {
+				signal?.throwIfAborted();
+				require_logger.logger.warn(`Could not resume a paused Claude turn, so the output may be incomplete: ${err instanceof Error ? err.message : String(err)}`);
+				break;
+			}
+			turnContent = [...turnContent, ...message.content];
+		}
+		return {
+			...message,
+			content: turnContent
+		};
+	}
+	async resolveMcpToolUse({ config, headers, initialResponse, params, responses, shouldStream, signal }) {
+		const toolCalls = [];
+		const unchanged = () => ({
+			response: withMergedAnthropicUsage(initialResponse, responses),
+			responses,
+			toolCalls
+		});
+		if (!this.mcpClient) return unchanged();
+		const mcpToolNames = new Set(this.mcpClient.getAllTools().map((tool) => tool.name));
+		if (mcpToolNames.size === 0) return unchanged();
+		const maxToolCalls = getMaxMcpToolCalls(config);
+		if (maxToolCalls === 0) return unchanged();
+		let response = initialResponse;
+		let messages = params.messages;
+		let executedMcpToolCalls = 0;
+		for (let iteration = 0; iteration < maxToolCalls; iteration++) {
+			signal?.throwIfAborted();
+			const responseToolUses = response.content.filter((block) => block.type === "tool_use");
+			const toolUses = responseToolUses.filter((block) => mcpToolNames.has(block.name));
+			if (toolUses.length === 0) return {
+				response: withMergedAnthropicUsage(response, responses),
+				responses,
+				toolCalls
+			};
+			if (toolUses.length !== responseToolUses.length) {
+				require_logger.logger.warn("Skipping Anthropic MCP continuation because the response mixes MCP and non-MCP tool_use blocks.");
+				return {
+					response: withMergedAnthropicUsage(response, responses),
+					responses,
+					toolCalls
+				};
+			}
+			if (executedMcpToolCalls + toolUses.length > maxToolCalls) return {
+				response: withMergedAnthropicUsage(response, responses),
+				responses,
+				error: `Anthropic MCP tool execution exceeded max_tool_calls=${maxToolCalls}. Increase provider config.max_tool_calls if this evaluation legitimately needs more tool calls.`,
+				toolCalls
+			};
+			executedMcpToolCalls += toolUses.length;
+			const toolResultBlocks = await Promise.all(toolUses.map((toolUse) => this.callMcpToolForAnthropic(toolUse)));
+			toolUses.forEach((toolUse, index) => {
+				const resultBlock = toolResultBlocks[index];
+				toolCalls.push({
+					id: toolUse.id,
+					name: toolUse.name,
+					input: coerceMcpToolInput(toolUse.input),
+					output: resultBlock.content,
+					is_error: resultBlock.is_error ?? false
+				});
+			});
+			messages = [
+				...messages,
+				{
+					role: "assistant",
+					content: response.content
+				},
+				{
+					role: "user",
+					content: toolResultBlocks
+				}
+			];
+			response = await this.sendMessage(getMcpContinuationParams(params, messages), headers, shouldStream, responses, signal);
+		}
+		const unresolvedToolUses = response.content.filter((block) => block.type === "tool_use" && mcpToolNames.has(block.name));
+		return {
+			response: withMergedAnthropicUsage(response, responses),
+			responses,
+			toolCalls,
+			...unresolvedToolUses.length > 0 ? { error: `Anthropic MCP tool execution exceeded max_tool_calls=${maxToolCalls}. Increase provider config.max_tool_calls if this evaluation legitimately needs more tool calls.` } : {}
+		};
+	}
+	async callMcpToolForAnthropic(toolUse) {
+		try {
+			const result = await this.mcpClient.callTool(toolUse.name, coerceMcpToolInput(toolUse.input));
+			if (require_util.isMcpErrorResult(result)) return {
+				type: "tool_result",
+				tool_use_id: toolUse.id,
+				content: `MCP Tool Error (${toolUse.name}): ${require_util.getMcpErrorMessage(result)}`,
+				is_error: true
+			};
+			return {
+				type: "tool_result",
+				tool_use_id: toolUse.id,
+				content: require_util.normalizeMcpToolContent(result.content)
+			};
+		} catch (error) {
+			return {
+				type: "tool_result",
+				tool_use_id: toolUse.id,
+				content: `MCP Tool Error (${toolUse.name}): ${error instanceof Error ? error.message : String(error)}`,
+				is_error: true
+			};
+		}
+	}
+	toString() {
+		if (!this.modelName) throw new Error("Anthropic model name is not set. Please provide a valid model name.");
+		return `[Anthropic Messages Provider ${this.modelName}]`;
+	}
+	getGenAISystem() {
+		return "anthropic";
+	}
+	sanitizeRequestHeaders(headers) {
+		return headers;
+	}
+	allowsClaudeGenerationFallback() {
+		return URL.canParse(this.anthropic.baseURL) && new URL(this.anthropic.baseURL).hostname.toLowerCase() === "api.anthropic.com";
+	}
+	/** Adapters with transport-managed authentication can defer validation to HTTP dispatch. */
+	validateAuthentication() {
+		if (!this.apiKey && !this.usingClaudeCodeOAuth) throw new Error("Anthropic API key is not set. Set the ANTHROPIC_API_KEY environment variable or add `apiKey` to the provider config. Alternatively, if you have an active Claude Code session, set `apiKeyRequired: false` in the provider config to authenticate via Claude Code.");
+	}
+	/** Independent of authentication: adapters decide whether their response cache is safe. */
+	shouldCacheResponses() {
+		return true;
+	}
+	async callApi(prompt, context, options) {
+		if (options?.abortSignal?.aborted) return { error: "Operation aborted" };
+		await this.initializeMCP(options?.abortSignal);
+		this.validateAuthentication();
+		if (this.usingClaudeCodeOAuth && this.claudeCodeCredential && isCredentialExpired(this.claudeCodeCredential)) throw new Error("Claude Code OAuth credential is expired. Run `claude /login` to refresh it, then re-run the eval.");
+		if (!this.modelName) throw new Error("Anthropic model name is not set. Please provide a valid model name.");
+		const spanContext = {
+			system: this.getGenAISystem(),
+			operationName: "chat",
+			model: this.modelName,
+			providerId: this.id(),
+			maxTokens: this.config.max_tokens,
+			temperature: this.config.temperature,
+			testIndex: context?.testIdx ?? context?.test?.vars?.__testIdx,
+			promptLabel: context?.prompt?.label,
+			traceparent: context?.traceparent,
+			requestBody: prompt
+		};
+		const resultExtractor = (response) => {
+			const result = {};
+			if (response.tokenUsage) result.tokenUsage = {
+				prompt: response.tokenUsage.prompt,
+				completion: response.tokenUsage.completion,
+				total: response.tokenUsage.total,
+				cached: response.tokenUsage.cached,
+				completionDetails: response.tokenUsage.completionDetails
+			};
+			if (response.finishReason) result.finishReasons = [response.finishReason];
+			if (response.cached !== void 0) result.cacheHit = response.cached;
+			if (response.output !== void 0) result.responseBody = typeof response.output === "string" ? response.output : JSON.stringify(response.output);
+			return result;
+		};
+		return require_genaiTracer.withGenAISpan(spanContext, () => this.callApiInternal(prompt, context, options), resultExtractor);
+	}
+	/**
+	* Reconcile a requested thinking config with what the target model actually accepts, and
+	* report whether the request will end up thinking.
+	*
+	* Three model-level rules apply, each verified against the live API:
+	* - Manual budget thinking (`type: 'enabled'`) is rejected on adaptive-only models and is
+	*   converted to `type: 'adaptive'`.
+	* - `type: 'disabled'` is rejected outright on always-on models, and on
+	*   Opus 5 when `effort` is `xhigh`/`max`. In both cases it is dropped rather than sent.
+	* - On Opus 5 and Sonnet 5 an *omitted* thinking config still runs adaptive thinking, so it
+	*   consumes output tokens — callers size the default `max_tokens` off this, and treating it
+	*   as disabled truncates responses mid-answer.
+	*
+	* Warnings are emitted at most once per provider instance.
+	*/
+	resolveModelThinking(requested, effort, flags) {
+		const { samplingParamsDeprecated, alwaysOnAdaptiveThinking, modelWarningName } = flags;
+		if ((samplingParamsDeprecated || alwaysOnAdaptiveThinking) && requested?.type === "enabled") {
+			if (!this.manualThinkingConversionWarned) {
+				require_logger.logger.warn(alwaysOnAdaptiveThinking ? `Adaptive thinking is always on for ${modelWarningName}. Manual thinking budgets have been removed; use effort to control reasoning depth.` : `Manual extended thinking (thinking.type "enabled") is not supported on ${modelWarningName} and has been converted to adaptive thinking. Use thinking: { type: "adaptive" } with effort to control reasoning depth.`);
+				this.manualThinkingConversionWarned = true;
+			}
+		} else if (requested?.type === "disabled" && !this.disabledThinkingRemovalWarned) {
+			const betweenTools = require_util$1.isBetweenToolsLowestThinkingClaudeModel(this.modelName);
+			if (alwaysOnAdaptiveThinking) {
+				require_logger.logger.warn(`Adaptive thinking is always on for ${modelWarningName}. thinking.type "disabled" has been omitted.`);
+				this.disabledThinkingRemovalWarned = true;
+			} else if (require_util$1.isDisabledThinkingRejectedAtEffort(this.modelName, effort)) {
+				require_logger.logger.warn(`${modelWarningName} only accepts thinking.type "${betweenTools ? "between_tools" : "disabled"}" at effort "high" or below (got "${effort}"), so thinking.type "disabled" has been omitted. Lower effort to "high" if you need thinking off.`);
+				this.disabledThinkingRemovalWarned = true;
+			} else if (betweenTools) {
+				require_logger.logger.warn(`${modelWarningName} does not accept thinking.type "disabled", so it has been sent as "between_tools", the model's lowest setting, which turns off up-front thinking. Set thinking.type "between_tools" to silence this warning.`);
+				this.disabledThinkingRemovalWarned = true;
+			}
+		} else if (requested?.type === "between_tools" && !this.disabledThinkingRemovalWarned && require_util$1.isBetweenToolsLowestThinkingClaudeModel(this.modelName) && require_util$1.isDisabledThinkingRejectedAtEffort(this.modelName, effort)) {
+			require_logger.logger.warn(`${modelWarningName} only accepts thinking.type "between_tools" at effort "high" or below (got "${effort}"), so it has been omitted and the model thinks adaptively. Lower effort to "high" to turn off up-front thinking.`);
+			this.disabledThinkingRemovalWarned = true;
+		}
+		const resolved = require_util$1.normalizeClaudeThinkingConfig(this.modelName, requested, effort, { allowGenerationFallback: samplingParamsDeprecated });
+		return {
+			thinking: resolved,
+			thinkingEnabled: alwaysOnAdaptiveThinking || require_util$1.isClaudeThinkingEnabled(resolved),
+			thinkingConsumesTokens: require_util$1.claudeThinkingConsumesTokens(this.modelName, resolved)
+		};
+	}
+	/**
+	* Build the ProviderResponse for a completed Anthropic message.
+	*
+	* Shared by the cache-hit and fresh-call paths, which are otherwise identical. `cached`
+	* drives the only three differences: token usage is attributed to the cache, the refusal
+	* warning is suppressed (it was already logged when the response was first fetched), and
+	* the `cached` marker is set. Keeping one builder is what stops the two paths drifting —
+	* they have diverged before, which is why the cached-refusal regression test exists.
+	*/
+	buildMessageResponse(message, config, processedOutputFormat, cached) {
+		const finishReason = require_finishReason.normalizeFinishReason(message.stop_reason);
+		let output = require_util$1.outputFromMessage(message, config.showThinking ?? true);
+		const isStructuredOutput = processedOutputFormat?.type === "json_schema";
+		const fileReferences = message.fileReferences ?? message.content.flatMap(require_util$1.getFileReferences);
+		if (isStructuredOutput) {
+			const text = message.stop_reason === "pause_turn" || message.content.some((block) => block.type === "tool_use") ? "" : message.finalText ?? message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+			try {
+				output = JSON.parse(text || output);
+			} catch (error) {
+				require_logger.logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+			}
+		}
+		const refusalDetails = require_util$1.getRefusalDetails(message);
+		if (refusalDetails && !cached) require_logger.logger.warn(refusalDetails);
+		return {
+			output,
+			...fileReferences.length > 0 && { metadata: { fileReferences } },
+			tokenUsage: require_util$1.getTokenUsage(message, cached),
+			...finishReason && { finishReason },
+			...refusalDetails && { guardrails: {
+				flagged: true,
+				reason: refusalDetails
+			} },
+			cost: this.calculateMessageCosts(config, message.billedCalls ?? [message]),
+			...cached && { cached: true }
+		};
+	}
+	/**
+	* Internal implementation of callApi without tracing wrapper.
+	*/
+	async callApiInternal(prompt, context, options) {
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const { system, extractedMessages, thinking } = require_util$1.parseMessages(prompt);
+		let mcpTools = [];
+		if (this.mcpClient) mcpTools = require_transform.transformMCPToolsToAnthropic(this.mcpClient.getAllTools());
+		const loadedTools = await require_file.maybeLoadToolsFromExternalFile(config.tools, context?.vars) || [];
+		const configTools = require_shared.transformTools(loadedTools, "anthropic");
+		const { processedTools: processedConfigTools, requiredBetaFeatures } = require_util$1.processAnthropicTools(configTools);
+		const allTools = [...mcpTools, ...processedConfigTools];
+		const processedOutputFormat = require_file.maybeLoadResponseFormatFromExternalFile(config.output_format, context?.vars);
+		const samplingParamsDeprecated = require_util$1.isSamplingParamsDeprecatedClaudeModel(this.modelName, { allowGenerationFallback: this.allowsClaudeGenerationFallback() });
+		const alwaysOnAdaptiveThinking = require_util$1.isAlwaysOnAdaptiveThinkingClaudeModel(this.modelName);
+		const modelWarningName = require_util$1.getClaudeModelWarningName(this.modelName) ?? "this Claude model";
+		const { thinking: resolvedThinking, thinkingEnabled, thinkingConsumesTokens } = this.resolveModelThinking(config.thinking ?? thinking, config.effort, {
+			samplingParamsDeprecated,
+			alwaysOnAdaptiveThinking,
+			modelWarningName
+		});
+		const modelRejectsForcedToolChoice = require_util$1.isForcedToolChoiceUnsupportedClaudeModel(this.modelName);
+		const forcedToolChoiceRejected = resolvedThinking?.type === "enabled" || modelRejectsForcedToolChoice;
+		let resolvedToolChoice;
+		if (config.tool_choice) {
+			const transformed = require_shared.transformToolChoice(config.tool_choice, "anthropic");
+			if (forcedToolChoiceRejected && (transformed.type === "any" || transformed.type === "tool")) require_logger.logger.warn(modelRejectsForcedToolChoice ? `tool_choice type '${transformed.type}' (forced tool use) is not supported on ${modelWarningName} and will be omitted. Use 'auto' or 'none' instead.` : `tool_choice type '${transformed.type}' (forced tool use) is incompatible with extended thinking and will be omitted. Use 'auto' or remove tool_choice.`);
+			else resolvedToolChoice = transformed;
+		}
+		const envTemperature = require_logger.parseEnvFloat(this.env?.ANTHROPIC_TEMPERATURE ?? require_logger.getEnvString("ANTHROPIC_TEMPERATURE"));
+		const { sampling, warnings: samplingWarnings } = require_util$1.resolveClaudeSamplingParams(config, {
+			thinkingEnabled,
+			samplingParamsDeprecated,
+			defaultTemperature: envTemperature ?? 0
+		});
+		for (const warning of samplingWarnings) require_logger.logger.warn(warning);
+		const explicitSamplingParam = config.temperature != null || config.top_p != null || config.top_k != null || envTemperature != null;
+		if (samplingParamsDeprecated && explicitSamplingParam && !this.samplingParamsDeprecationWarned) {
+			require_logger.logger.warn(alwaysOnAdaptiveThinking ? `temperature, top_p, and top_k are not supported on ${modelWarningName} and will be omitted. Remove these sampling parameters from your config (or unset ANTHROPIC_TEMPERATURE) to silence this warning.` : `temperature is deprecated on ${modelWarningName} and will be omitted (along with top_p and top_k). Remove these sampling parameters from your config (or unset ANTHROPIC_TEMPERATURE) to silence this warning.`);
+			this.samplingParamsDeprecationWarned = true;
+		}
+		const resolvedSystem = this.usingClaudeCodeOAuth ? [{
+			type: "text",
+			text: CLAUDE_CODE_IDENTITY_PROMPT
+		}, ...system ?? []] : system;
+		const shouldStream = config.stream ?? false;
+		const params = {
+			model: this.modelName,
+			...resolvedSystem && resolvedSystem.length > 0 ? { system: resolvedSystem } : {},
+			max_tokens: require_util$1.clampMaxTokensForThinkingBudget(config.max_tokens ?? require_logger.getEnvInt("ANTHROPIC_MAX_TOKENS", thinkingConsumesTokens ? 2048 : 1024), resolvedThinking),
+			messages: extractedMessages,
+			stream: shouldStream,
+			...sampling,
+			...config.cache_control ? { cache_control: config.cache_control } : {},
+			...config.service_tier ? { service_tier: config.service_tier } : {},
+			...config.stop_sequences?.length ? { stop_sequences: config.stop_sequences } : {},
+			...config.metadata ? { metadata: config.metadata } : {},
+			...allTools.length > 0 ? { tools: allTools } : {},
+			...resolvedToolChoice ? { tool_choice: resolvedToolChoice } : {},
+			...resolvedThinking ? { thinking: resolvedThinking } : {},
+			...processedOutputFormat || config.effort ? { output_config: {
+				...processedOutputFormat ? { format: processedOutputFormat } : {},
+				...config.effort ? { effort: config.effort } : {}
+			} } : {},
+			...typeof config?.extra_body === "object" && config.extra_body ? config.extra_body : {}
+		};
+		require_logger.logger.debug("Calling Anthropic Messages API", { params: getMessagesRequestMetadata(params) });
+		const headers = this.sanitizeRequestHeaders({ ...config.headers || {} });
+		let allBetaFeatures = [...config.beta || [], ...requiredBetaFeatures];
+		const userBetaHeader = config.headers?.["anthropic-beta"];
+		if (typeof userBetaHeader === "string" && userBetaHeader.length > 0) allBetaFeatures.push(...userBetaHeader.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+		if (processedOutputFormat && !allBetaFeatures.includes("structured-outputs-2025-11-13")) allBetaFeatures.push("structured-outputs-2025-11-13");
+		if (this.usingClaudeCodeOAuth) allBetaFeatures.push(...CLAUDE_CODE_OAUTH_BETA_FEATURES);
+		allBetaFeatures = [...new Set(allBetaFeatures)];
+		if (allBetaFeatures.length > 0) headers["anthropic-beta"] = allBetaFeatures.join(",");
+		if (this.usingClaudeCodeOAuth) {
+			headers["user-agent"] = CLAUDE_CODE_USER_AGENT;
+			headers["x-app"] = "cli";
+		}
+		const shouldUseResponseCache = require_cache.isCacheEnabled() && config.mcp?.enabled !== true && this.shouldCacheResponses() && !this.hasCustomHeaders() && Object.keys(config.headers ?? {}).length === 0;
+		const cache = shouldUseResponseCache ? await require_cache.getCache() : void 0;
+		const { metadata: _metadata, ...cacheKeyParams } = params;
+		const cacheKeyHeaders = normalizeHeadersForCacheKey(headers);
+		const cacheKey = shouldUseResponseCache ? `anthropic:messages:${this.modelName}:${this.getCacheIdentityHash()}:${this.getCacheNamespace()}:${hashAnthropicCacheValue({
+			...cacheKeyParams,
+			...cacheKeyHeaders ? { headers: cacheKeyHeaders } : {}
+		})}` : void 0;
+		const ephemeralCacheKey = cacheKey ? require_cache.getScopedCacheKey(cacheKey) : void 0;
+		const cacheClearGeneration = require_cache.getCacheClearGeneration();
+		if (cache && cacheKey && ephemeralCacheKey) {
+			const cachedResponse = await this.getCachedResponse(cache, cacheKey, ephemeralCacheKey, cacheClearGeneration);
+			if (cachedResponse) try {
+				const cachedMessage = JSON.parse(cachedResponse);
+				if (cachedMessage.stop_reason !== "pause_turn") {
+					require_logger.logger.debug("Returning cached Anthropic Messages response", { model: this.modelName });
+					return this.buildMessageResponse(cachedMessage, config, processedOutputFormat, true);
+				}
+			} catch {
+				return {
+					output: cachedResponse,
+					cached: true,
+					tokenUsage: require_tokenUsageUtils.createEmptyTokenUsage()
+				};
+			}
+		}
+		const responses = [];
+		try {
+			const signal = options?.abortSignal;
+			const initialMessage = await this.sendMessage(params, headers, shouldStream, responses, signal);
+			signal?.throwIfAborted();
+			const { error, response: resolvedMessage, toolCalls } = await this.resolveMcpToolUse({
+				config,
+				headers,
+				initialResponse: initialMessage,
+				params,
+				responses,
+				shouldStream,
+				signal
+			});
+			const cost = this.calculateMessageCosts(config, responses);
+			const mcpMetadata = toolCalls.length > 0 ? { toolCalls } : void 0;
+			if (error) return {
+				error,
+				tokenUsage: require_util$1.getTokenUsage(resolvedMessage, false),
+				cost,
+				...mcpMetadata ? { metadata: mcpMetadata } : {}
+			};
+			const message = toCachedMessage(resolvedMessage, responses);
+			if (cache && cacheKey && ephemeralCacheKey && message.stop_reason !== "pause_turn") try {
+				await this.setCachedResponse(cache, cacheKey, ephemeralCacheKey, cacheClearGeneration, require_cache.getCacheTtlMs(), JSON.stringify(message));
+			} catch (err) {
+				require_logger.logger.error(`Failed to cache response: ${String(err)}`);
+			}
+			const outputMessage = require_util$1.isClaudeSonnet55Model(this.modelName) ? {
+				...message,
+				content: [...responses.slice(0, -1).flatMap((turn) => turn.content.filter((block) => block.type === "thinking" && !message.content.includes(block))), ...message.content]
+			} : message;
+			const response = this.buildMessageResponse(outputMessage, config, processedOutputFormat, false);
+			return mcpMetadata ? {
+				...response,
+				metadata: {
+					...response.metadata,
+					...mcpMetadata
+				}
+			} : response;
+		} catch (err) {
+			require_logger.logger.error(`Anthropic Messages API call error: ${err instanceof Error ? err.message : String(err)}`);
+			let error = `API call error: ${err instanceof Error ? err.message : String(err)}`;
+			if (err instanceof _anthropic_ai_sdk.APIError && err.error) {
+				const errorDetails = err.error;
+				error = `API call error: ${errorDetails.error.message}, status ${err.status}, type ${errorDetails.error.type}`;
+			}
+			const lastResponse = responses[responses.length - 1];
+			return {
+				error,
+				...lastResponse ? {
+					tokenUsage: require_util$1.getTokenUsage(withMergedAnthropicUsage(lastResponse, responses), false),
+					cost: this.calculateMessageCosts(config, responses)
+				} : {}
+			};
+		}
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AnthropicGenericProvider", {
+	enumerable: true,
+	get: function() {
+		return AnthropicGenericProvider;
+	}
+});
+Object.defineProperty(exports, "AnthropicMessagesProvider", {
+	enumerable: true,
+	get: function() {
+		return AnthropicMessagesProvider;
+	}
+});
+Object.defineProperty(exports, "buildIsolatedAnthropicClientOptions", {
+	enumerable: true,
+	get: function() {
+		return buildIsolatedAnthropicClientOptions;
+	}
+});
+Object.defineProperty(exports, "getAnthropicEnvHeaderSuppressions", {
+	enumerable: true,
+	get: function() {
+		return getAnthropicEnvHeaderSuppressions;
+	}
+});
+Object.defineProperty(exports, "hashAnthropicCacheValue", {
+	enumerable: true,
+	get: function() {
+		return hashAnthropicCacheValue;
+	}
+});
+
+//# sourceMappingURL=messages-Cv_m6kYs.cjs.map