promptfoo 0.125.0 → 0.125.1

package/dist/src/messages-BE_eZ7NA.js

@@ -1,1127 +0,0 @@
-import { J as getEnvInt, X as getEnvString, Y as getEnvOverrides, et as getProviderEnvString, it as parseEnvFloat, o as logger, ot as getExplicitProviderEnv } from "./logger-Gff7RMNF.js";
-import "./dataUrl-C9J7wz9H.js";
-import { _ as transformToolChoice, v as transformTools } from "./shared-BBI-NXjW.js";
-import { n as resolveProviderApiKey } from "./credentials-DH6z4brQ.js";
-import { h as withGenAISpan } from "./genaiTracer-CuSjHi4t.js";
-import { c as getCacheTtlMs, l as getScopedCacheKey, o as getCache, s as getCacheClearGeneration, u as isCacheEnabled } from "./cache-CEYhFUsH.js";
-import { c as maybeLoadToolsFromExternalFile, s as maybeLoadResponseFormatFromExternalFile } from "./file-Di0ypTgN.js";
-import { d as createEmptyTokenUsage } from "./tokenUsageUtils-BfzeNdYY.js";
-import { n as normalizeFinishReason } from "./finishReason-BixMIdSI.js";
-import { c as normalizeMcpToolContent, i as getMcpErrorMessage, o as isMcpErrorResult } from "./util-CSSAWO8v.js";
-import { t as McpClientSession } from "./session-_0-rTdwY.js";
-import { n as transformMCPToolsToAnthropic } from "./transform-_i1raQNo.js";
-import { A as parseMessages, C as isForcedToolChoiceUnsupportedClaudeModel, D as normalizeAnthropicModelName, M as resolveClaudeSamplingParams, O as normalizeClaudeThinkingConfig, S as isDisabledThinkingRejectedAtEffort, a as calculateAnthropicCost, c as claudeThinkingConsumesTokens, d as getRefusalDetails, f as getTokenUsage, j as processAnthropicTools, k as outputFromMessage, l as getClaudeModelWarningName, m as isBetweenToolsLowestThinkingClaudeModel, p as isAlwaysOnAdaptiveThinkingClaudeModel, s as clampMaxTokensForThinkingBudget, t as ANTHROPIC_MODELS, u as getFileReferences, w as isSamplingParamsDeprecatedClaudeModel, x as isClaudeThinkingEnabled, y as isClaudeSonnet55Model } from "./util-PfQ60chz.js";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { createHash as createHash$1, randomUUID as randomUUID$1 } from "crypto";
-import { execFileSync } from "node:child_process";
-import Anthropic, { APIError } from "@anthropic-ai/sdk";
-//#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 || 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) ?? path.join(os.homedir(), ".claude");
-}
-function resolveCredentialsPath(env) {
-	return path.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 = 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 = 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) {
-			logger.debug("[anthropic] No Claude Code credential entry in the macOS keychain; trying file fallback.");
-			return null;
-		}
-		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) {
-		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) {
-		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 (!fs.existsSync(filePath)) return null;
-	let raw;
-	try {
-		raw = fs.readFileSync(filePath, "utf-8");
-	} catch (err) {
-		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) {
-		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 getExplicitProviderEnv(env)?.ANTHROPIC_CUSTOM_HEADERS ?? getEnvOverrides("provider")?.ANTHROPIC_CUSTOM_HEADERS ?? env?.ANTHROPIC_CUSTOM_HEADERS ?? getEnvOverrides()?.ANTHROPIC_CUSTOM_HEADERS ?? 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 createHash$1("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 = randomUUID$1();
-	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) ?? 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)) logger.warn("[anthropic] Claude Code OAuth credential is expired. Run `claude /login` to refresh it.");
-				else 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 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(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 resolveProviderApiKey(this.config, this.env, ["ANTHROPIC_API_KEY"]);
-	}
-	getApiBaseUrl() {
-		const envUrl = getProviderEnvString(this.env, "ANTHROPIC_BASE_URL") ?? 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) ?? 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: 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(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 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 = ANTHROPIC_MODELS;
-	static ANTHROPIC_MODELS_NAMES = 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(normalizeAnthropicModelName(modelName))) 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 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);
-			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) {
-				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();
-				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) {
-				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 (isMcpErrorResult(result)) return {
-				type: "tool_result",
-				tool_use_id: toolUse.id,
-				content: `MCP Tool Error (${toolUse.name}): ${getMcpErrorMessage(result)}`,
-				is_error: true
-			};
-			return {
-				type: "tool_result",
-				tool_use_id: toolUse.id,
-				content: 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 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) {
-				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 = isBetweenToolsLowestThinkingClaudeModel(this.modelName);
-			if (alwaysOnAdaptiveThinking) {
-				logger.warn(`Adaptive thinking is always on for ${modelWarningName}. thinking.type "disabled" has been omitted.`);
-				this.disabledThinkingRemovalWarned = true;
-			} else if (isDisabledThinkingRejectedAtEffort(this.modelName, effort)) {
-				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) {
-				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 && isBetweenToolsLowestThinkingClaudeModel(this.modelName) && isDisabledThinkingRejectedAtEffort(this.modelName, effort)) {
-			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 = normalizeClaudeThinkingConfig(this.modelName, requested, effort, { allowGenerationFallback: samplingParamsDeprecated });
-		return {
-			thinking: resolved,
-			thinkingEnabled: alwaysOnAdaptiveThinking || isClaudeThinkingEnabled(resolved),
-			thinkingConsumesTokens: 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 = normalizeFinishReason(message.stop_reason);
-		let output = outputFromMessage(message, config.showThinking ?? true);
-		const isStructuredOutput = processedOutputFormat?.type === "json_schema";
-		const fileReferences = message.fileReferences ?? message.content.flatMap(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) {
-				logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
-			}
-		}
-		const refusalDetails = getRefusalDetails(message);
-		if (refusalDetails && !cached) logger.warn(refusalDetails);
-		return {
-			output,
-			...fileReferences.length > 0 && { metadata: { fileReferences } },
-			tokenUsage: 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 } = parseMessages(prompt);
-		let mcpTools = [];
-		if (this.mcpClient) mcpTools = transformMCPToolsToAnthropic(this.mcpClient.getAllTools());
-		const loadedTools = await maybeLoadToolsFromExternalFile(config.tools, context?.vars) || [];
-		const configTools = transformTools(loadedTools, "anthropic");
-		const { processedTools: processedConfigTools, requiredBetaFeatures } = processAnthropicTools(configTools);
-		const allTools = [...mcpTools, ...processedConfigTools];
-		const processedOutputFormat = maybeLoadResponseFormatFromExternalFile(config.output_format, context?.vars);
-		const samplingParamsDeprecated = isSamplingParamsDeprecatedClaudeModel(this.modelName, { allowGenerationFallback: this.allowsClaudeGenerationFallback() });
-		const alwaysOnAdaptiveThinking = isAlwaysOnAdaptiveThinkingClaudeModel(this.modelName);
-		const modelWarningName = getClaudeModelWarningName(this.modelName) ?? "this Claude model";
-		const { thinking: resolvedThinking, thinkingEnabled, thinkingConsumesTokens } = this.resolveModelThinking(config.thinking ?? thinking, config.effort, {
-			samplingParamsDeprecated,
-			alwaysOnAdaptiveThinking,
-			modelWarningName
-		});
-		const modelRejectsForcedToolChoice = isForcedToolChoiceUnsupportedClaudeModel(this.modelName);
-		const forcedToolChoiceRejected = resolvedThinking?.type === "enabled" || modelRejectsForcedToolChoice;
-		let resolvedToolChoice;
-		if (config.tool_choice) {
-			const transformed = transformToolChoice(config.tool_choice, "anthropic");
-			if (forcedToolChoiceRejected && (transformed.type === "any" || transformed.type === "tool")) 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 = parseEnvFloat(this.env?.ANTHROPIC_TEMPERATURE ?? getEnvString("ANTHROPIC_TEMPERATURE"));
-		const { sampling, warnings: samplingWarnings } = resolveClaudeSamplingParams(config, {
-			thinkingEnabled,
-			samplingParamsDeprecated,
-			defaultTemperature: envTemperature ?? 0
-		});
-		for (const warning of samplingWarnings) logger.warn(warning);
-		const explicitSamplingParam = config.temperature != null || config.top_p != null || config.top_k != null || envTemperature != null;
-		if (samplingParamsDeprecated && explicitSamplingParam && !this.samplingParamsDeprecationWarned) {
-			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: clampMaxTokensForThinkingBudget(config.max_tokens ?? 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 : {}
-		};
-		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 = isCacheEnabled() && config.mcp?.enabled !== true && this.shouldCacheResponses() && !this.hasCustomHeaders() && Object.keys(config.headers ?? {}).length === 0;
-		const cache = shouldUseResponseCache ? await 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 ? getScopedCacheKey(cacheKey) : void 0;
-		const cacheClearGeneration = 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") {
-					logger.debug("Returning cached Anthropic Messages response", { model: this.modelName });
-					return this.buildMessageResponse(cachedMessage, config, processedOutputFormat, true);
-				}
-			} catch {
-				return {
-					output: cachedResponse,
-					cached: true,
-					tokenUsage: 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: 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, getCacheTtlMs(), JSON.stringify(message));
-			} catch (err) {
-				logger.error(`Failed to cache response: ${String(err)}`);
-			}
-			const outputMessage = 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) {
-			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 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: getTokenUsage(withMergedAnthropicUsage(lastResponse, responses), false),
-					cost: this.calculateMessageCosts(config, responses)
-				} : {}
-			};
-		}
-	}
-};
-//#endregion
-export { hashAnthropicCacheValue as a, getAnthropicEnvHeaderSuppressions as i, AnthropicGenericProvider as n, buildIsolatedAnthropicClientOptions as r, AnthropicMessagesProvider as t };
-
-//# sourceMappingURL=messages-BE_eZ7NA.js.map