@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/anthropic-ClCw0PV_.mjs

@@ -1,3624 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { r as __exportAll } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { $ as isEnoent, C as warn, N as $env, a as readSseEvents, b as debug, g as parseJsonWithRepair, q as getInstallId, v as parseStreamingJsonThrottled } from "./src-AELUUb5U.mjs";
-import { A as isTransientStreamParseError, D as isFastModeUnsupported, F as AnthropicStreamEnvelopeError, M as AnthropicApiError, N as AnthropicConnectionError, O as isGrammarError, P as AnthropicConnectionTimeoutError, _ as AbortError, a as isTransientStatus, c as finalize, d as getRetryAfterMsFromHeaders, i as isProviderRetryableError, k as isStreamEnvelopeError, l as finalizeErrorMessage, n as StreamTimeoutError, r as ValidationError, s as ProviderResponseError, t as ConfigurationError, u as getHeadersFromError } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, B as spillToDescription, C as kStreamingLastParseLen, T as renderDemotedThinking, V as COMBINATOR_KEYS, b as kStreamingBlockIndex, c as resolveCacheRetention, g as clearStreamingPartialJson, h as transformMessages, j as NO_STRICT, n as getHeaderCaseInsensitive, o as normalizeSystemPrompts, s as normalizeToolCallId, w as kStreamingPartialJson } from "./utils-cZX3f_Ls.mjs";
-import { n as isRecord } from "./type-guards-CttAANEx.mjs";
-import { At as withReplaySafeStreamRetry, Ct as applyInferenceHeaders, et as getOpenAIPromptCacheKey, f as isFoundryEnabled, n as getEnvApiKey, t as OUTPUT_FALLBACK_BUFFER, wt as isForcedToolChoice } from "./stream-AVOoe5Hj.mjs";
-import { r as isAnthropicOAuthToken } from "./utils-I4I8azHN.mjs";
-import { a as mapEffortToAnthropicAdaptiveEffort, n as isAnthropicServerToolHistoryBlock, r as parseAnthropicInputTransformations, t as THINKING_BINDING_CONTROLS_BETA } from "./anthropic-wire-lbGAFzYb.mjs";
-import { t as createAbortSourceTracker } from "./abort-DZ54CaKU.mjs";
-import { n as getBundledModel, t as calculateCost } from "./models-DnXMYGcJ.mjs";
-import { a as resolveGitHubCopilotBaseUrl, b as parseGitHubCopilotApiKey, i as resolveCopilotRequestIdentity, n as hasCopilotVisionInput, o as wrapFetchForCopilotFallback, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-DnjGEbko.mjs";
-import { t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-BCpXWUj3.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { a as claudeCodeUserAgent, i as claudeCodeSystemInstruction, n as CLAUDE_CODE_MAX_OUTPUT_TOKENS, o as claudeCodeVersion, r as claudeCodeSdkVersion } from "./anthropic-Dv_GGX6g.mjs";
-import { n as isVertexRawPredictUrl, t as hostMatchesUrl } from "./hosts-00rjRzUD.mjs";
-import { a as isOfficialAnthropicApiUrl, i as isAnthropicSigningProxyUrl } from "./collapse-CkMNRNr7.mjs";
-import { a as getStreamIdleTimeoutMs, i as getStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout } from "./idle-iterator-D0ZXEcUq.mjs";
-import { t as notifyProviderResponse } from "./provider-response-SqKSkkUc.mjs";
-import { t as notifyRawSseEvent } from "./sse-debug-B-tkLCPW.mjs";
-import * as fs from "node:fs";
-import { scheduler } from "node:timers/promises";
-import * as nodeCrypto from "node:crypto";
-import * as tls from "node:tls";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/sdk-stream-timeout.ts
-/**
-* Shared helpers for mapping `StreamOptions.streamFirstEventTimeoutMs` onto
-* underlying SDK request-timeout options.
-*
-* The hint is intentionally not a watchdog — it just narrows the SDK's
-* "transport timeout" window so a stuck pre-stream request fails fast
-* instead of hanging on the default (often multi-minute) SDK timeout. Once
-* the stream actually starts, silence is not failure; callers must abort
-* to interrupt a quiet stream.
-*/
-/**
-* Coerce a caller-supplied `streamFirstEventTimeoutMs` into a positive integer suitable
-* for the SDK's `timeout` option. Returns `undefined` when the caller passed nothing,
-* a non-finite value, or a non-positive value (preserving the SDK's default).
-*/
-function resolveSdkTimeoutMs(streamFirstEventTimeoutMs) {
-	if (streamFirstEventTimeoutMs === void 0) return void 0;
-	if (!Number.isFinite(streamFirstEventTimeoutMs)) return void 0;
-	if (streamFirstEventTimeoutMs <= 0) return void 0;
-	return Math.trunc(streamFirstEventTimeoutMs);
-}
-/**
-* Build per-request SDK options that combine an abort signal with the optional
-* `streamFirstEventTimeoutMs` request-timeout hint.
-*
-* The returned `{ signal, timeout?, maxRetries? }` shape is compatible with both
-* OpenAI's and Anthropic's `RequestOptions` (and any other SDK that follows the
-* Stainless conventions), so callers from any of those providers can spread the
-* result directly into `client.X.create(params, requestOptions)`.
-*
-* When the hint is set, retries are forced to zero so the SDK does not silently
-* extend the caller's explicit deadline by re-attempting after a timeout.
-*/
-function createSdkStreamRequestOptions(signal, streamFirstEventTimeoutMs) {
-	const timeout = resolveSdkTimeoutMs(streamFirstEventTimeoutMs);
-	if (timeout === void 0) return { signal };
-	return {
-		signal,
-		timeout,
-		maxRetries: 0
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/anthropic-client.ts
-/**
-* Minimal HTTP client for the Anthropic Messages API.
-*
-* pi-ai builds every request header itself (`buildAnthropicHeaders`), serializes
-* the body itself (`buildParams`), and parses SSE frames itself
-* (`iterateAnthropicEvents`), so the only `@anthropic-ai/sdk` surface this
-* package ever exercised was URL assembly, auth-header injection, bounded
-* retries, the pre-response timeout, and HTTP-error-to-status mapping. This
-* module implements exactly that surface and nothing else.
-*
-* Behavioral contract (kept compatible with the SDK so downstream error
-* classification keeps working):
-* - Non-2xx responses throw {@link AnthropicApiError} whose `status` property
-*   carries the HTTP status and whose message is `"<status> <body>"`.
-* - Pre-response timeouts throw {@link AnthropicConnectionTimeoutError}
-*   ("Request timed out.").
-* - Caller aborts throw an `Error` with message "Request was aborted.".
-* - Retries: connection errors and 408/409/429/5xx (or `x-should-retry: true`)
-*   are retried up to `maxRetries` times, honoring `retry-after-ms` /
-*   `retry-after`, otherwise exponential backoff (0.5s * 2^n, capped at 8s,
-*   with up to 25% jitter).
-*/
-/** Default pre-response timeout, matching the SDK's 10-minute default. */
-const DEFAULT_TIMEOUT_MS = 6e5;
-/** Default retry budget, matching the SDK's default. */
-const DEFAULT_MAX_RETRIES = 2;
-const INITIAL_RETRY_DELAY_S = .5;
-const MAX_RETRY_DELAY_S = 8;
-function createAbortError() {
-	return new AbortError("Request was aborted.");
-}
-/** `x-should-retry` override, then 408/409/429/5xx. */
-function shouldRetryResponse(response) {
-	const shouldRetryHeader = response.headers.get("x-should-retry");
-	if (shouldRetryHeader === "true") return true;
-	if (shouldRetryHeader === "false") return false;
-	const status = response.status;
-	return isTransientStatus(status) || status === 409;
-}
-/** Server-suggested delay (`retry-after-ms`, then `retry-after` seconds or HTTP date). */
-function retryDelayFromHeaders(headers) {
-	if (!headers) return void 0;
-	const retryAfterMs = headers.get("retry-after-ms");
-	if (retryAfterMs) {
-		const ms = Number.parseFloat(retryAfterMs);
-		if (Number.isFinite(ms) && ms >= 0) return ms;
-	}
-	const retryAfter = headers.get("retry-after");
-	if (retryAfter) {
-		const seconds = Number.parseFloat(retryAfter);
-		if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
-		const dateMs = Date.parse(retryAfter) - Date.now();
-		if (Number.isFinite(dateMs) && dateMs >= 0) return dateMs;
-	}
-}
-function calculateAnthropicRetryDelayMs(attempt) {
-	return Math.min(INITIAL_RETRY_DELAY_S * 2 ** attempt, MAX_RETRY_DELAY_S) * (1 - Math.random() * .25) * 1e3;
-}
-function hasHeaderCaseInsensitive(headers, lowerName) {
-	for (const key in headers) if (key.toLowerCase() === lowerName) return true;
-	return false;
-}
-/**
-* Lazy in-flight request handle. The HTTP request starts on the first
-* `asResponse()` call; subsequent calls return the same promise.
-*
-* Shape-compatible with the SDK's `APIPromise.asResponse()` so
-* `getAnthropicStreamResponse` treats internal and injected clients uniformly.
-*/
-var AnthropicApiRequest = class {
-	#start;
-	#response;
-	constructor(start) {
-		this.#start = start;
-	}
-	asResponse() {
-		this.#response ??= this.#start();
-		return this.#response;
-	}
-};
-/**
-* `messages` resource. `create` lives on the prototype so tests can intercept
-* every outgoing request with `vi.spyOn(AnthropicMessages.prototype, "create")`.
-*/
-var AnthropicMessages = class {
-	#client;
-	#path;
-	constructor(client, path) {
-		this.#client = client;
-		this.#path = path;
-	}
-	create(params, options) {
-		return this.#client.request(this.#path, params, options);
-	}
-};
-var AnthropicMessagesClient = class {
-	messages;
-	beta;
-	#options;
-	constructor(options) {
-		this.#options = options;
-		this.messages = new AnthropicMessages(this, "/v1/messages");
-		this.beta = { messages: new AnthropicMessages(this, "/v1/messages?beta=true") };
-	}
-	request(path, params, options) {
-		return new AnthropicApiRequest(() => this.#send(path, params, options));
-	}
-	#buildHeaders(requestHeaders) {
-		const opts = this.#options;
-		const defaults = opts.defaultHeaders ?? {};
-		const headers = {};
-		if (opts.apiKey != null && !hasHeaderCaseInsensitive(defaults, "x-api-key")) headers["X-Api-Key"] = opts.apiKey;
-		if (opts.authToken != null && !hasHeaderCaseInsensitive(defaults, "authorization")) headers.Authorization = `Bearer ${opts.authToken}`;
-		Object.assign(headers, defaults);
-		Object.assign(headers, requestHeaders);
-		return headers;
-	}
-	async #send(path, params, options) {
-		const opts = this.#options;
-		const fetchFn = opts.fetch ?? fetch;
-		const callerSignal = options?.signal;
-		const timeoutMs = options?.timeout ?? opts.timeout ?? DEFAULT_TIMEOUT_MS;
-		const maxRetries = Math.max(0, options?.maxRetries ?? opts.maxRetries ?? DEFAULT_MAX_RETRIES);
-		const maxRetryDelayMs = options?.maxRetryDelayMs ?? opts.maxRetryDelayMs ?? 6e4;
-		const url = `${opts.baseURL ?? "https://api.anthropic.com"}${path}`;
-		const headers = this.#buildHeaders(options?.headers);
-		const body = JSON.stringify(params);
-		for (let attempt = 0;; attempt++) {
-			if (callerSignal?.aborted) throw createAbortError();
-			let response;
-			try {
-				response = await this.#fetchOnce(fetchFn, url, headers, body, timeoutMs, callerSignal);
-			} catch (error) {
-				if (callerSignal?.aborted) throw createAbortError();
-				if (attempt < maxRetries) {
-					await this.#backoff(attempt, void 0, callerSignal);
-					continue;
-				}
-				if (error instanceof AnthropicConnectionTimeoutError) throw error;
-				throw new AnthropicConnectionError(error);
-			}
-			if (response.ok) return response;
-			if (attempt < maxRetries && shouldRetryResponse(response)) {
-				const headerDelayMs = retryDelayFromHeaders(response.headers);
-				if (headerDelayMs !== void 0 && maxRetryDelayMs > 0 && headerDelayMs > maxRetryDelayMs) throw await AnthropicApiError.fromResponse(response, callerSignal);
-				await response.body?.cancel().catch(() => {});
-				await this.#backoff(attempt, response.headers, callerSignal);
-				continue;
-			}
-			throw await AnthropicApiError.fromResponse(response, callerSignal);
-		}
-	}
-	async #fetchOnce(fetchFn, url, headers, body, timeoutMs, callerSignal) {
-		const controller = new AbortController();
-		let timedOut = false;
-		const timer = setTimeout(() => {
-			timedOut = true;
-			controller.abort();
-		}, timeoutMs);
-		const onAbort = () => controller.abort();
-		callerSignal?.addEventListener("abort", onAbort, { once: true });
-		try {
-			return await fetchFn(url, {
-				...this.#options.fetchOptions,
-				method: "POST",
-				headers,
-				body,
-				signal: controller.signal
-			});
-		} catch (error) {
-			if (timedOut && !callerSignal?.aborted) throw new AnthropicConnectionTimeoutError();
-			throw error;
-		} finally {
-			clearTimeout(timer);
-			callerSignal?.removeEventListener("abort", onAbort);
-		}
-	}
-	async #backoff(attempt, responseHeaders, signal) {
-		const delayMs = retryDelayFromHeaders(responseHeaders) ?? calculateAnthropicRetryDelayMs(attempt);
-		try {
-			await scheduler.wait(delayMs, { signal });
-		} catch {
-			throw createAbortError();
-		}
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/anthropic.ts
-var anthropic_exports = /* @__PURE__ */ __exportAll({
-	CLAUDE_CODE_MAX_OUTPUT_TOKENS: () => CLAUDE_CODE_MAX_OUTPUT_TOKENS,
-	applyAnthropicUsageExtras: () => applyAnthropicUsageExtras,
-	applyClaudeToolPrefix: () => applyClaudeToolPrefix,
-	buildAnthropicClientOptions: () => buildAnthropicClientOptions,
-	buildAnthropicHeaders: () => buildAnthropicHeaders,
-	buildAnthropicSystemBlocks: () => buildAnthropicSystemBlocks,
-	buildBetaHeader: () => buildBetaHeader,
-	claudeCodeHeaders: () => claudeCodeHeaders,
-	claudeCodeSdkVersion: () => claudeCodeSdkVersion,
-	claudeCodeSystemInstruction: () => claudeCodeSystemInstruction,
-	claudeCodeUserAgent: () => claudeCodeUserAgent,
-	claudeCodeVersion: () => claudeCodeVersion,
-	claudeToolPrefix: () => "_",
-	convertAnthropicMessages: () => convertAnthropicMessages,
-	deriveClaudeDeviceId: () => deriveClaudeDeviceId,
-	isClaudeCloakingUserId: () => isClaudeCloakingUserId,
-	isInvalidThinkingSignatureError: () => isInvalidThinkingSignatureError,
-	isThinkingPrefixBindingError: () => isThinkingPrefixBindingError,
-	mapStainlessArch: () => mapStainlessArch,
-	mapStainlessOs: () => mapStainlessOs,
-	maybeAddReplayUnsignedThinkingHint: () => maybeAddReplayUnsignedThinkingHint,
-	normalizeAnthropicBaseUrl: () => normalizeAnthropicBaseUrl,
-	normalizeAnthropicToolSchema: () => normalizeAnthropicToolSchema,
-	normalizeExtraBetas: () => normalizeExtraBetas,
-	resolveAnthropicCustomHeadersForBaseUrl: () => resolveAnthropicCustomHeadersForBaseUrl,
-	resolveAnthropicMetadataUserId: () => resolveAnthropicMetadataUserId,
-	streamAnthropic: () => streamAnthropic,
-	stripClaudeToolPrefix: () => stripClaudeToolPrefix,
-	wrapFetchForCch: () => wrapFetchForCch
-});
-function normalizeAnthropicBaseUrl(baseUrl) {
-	const trimmed = baseUrl?.trim();
-	if (!trimmed) return;
-	const withoutTrailingSlashes = trimmed.replace(/\/+$/, "");
-	return withoutTrailingSlashes.endsWith("/v1") ? withoutTrailingSlashes.slice(0, -3) : withoutTrailingSlashes;
-}
-function buildBetaHeader(baseBetas, extraBetas) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const beta of [...baseBetas, ...extraBetas]) {
-		const trimmed = beta.trim();
-		if (trimmed && !seen.has(trimmed)) {
-			seen.add(trimmed);
-			result.push(trimmed);
-		}
-	}
-	return result.join(",");
-}
-/**
-* Merge an extra Anthropic beta into a caller-provided `anthropic-beta` header,
-* preserving the caller's key casing and deduping the tokens. Returns a
-* single-entry header record for a per-request `headers` override — used to
-* attach a required beta to injected SDK clients that bypass the client-level
-* beta construction.
-*/
-function mergeAnthropicBetaHeader(callerHeaders, beta) {
-	for (const key in callerHeaders) if (key.toLowerCase() === "anthropic-beta") return { [key]: buildBetaHeader(normalizeExtraBetas(callerHeaders[key]), [beta]) };
-	return { "anthropic-beta": beta };
-}
-const oauthAuthBeta = "oauth-2025-04-20";
-const midConversationSystemBeta = "mid-conversation-system-2026-04-07";
-const midConversationSystemClearAtBeta = "mid-conversation-system-clear-at-2026-08-21";
-const midConversationToolChangesBeta = "mid-conversation-tool-changes-2026-07-01";
-const midConversationOutputConfigBeta = "mid-conversation-output-config-2026-07-01";
-const contextManagementBeta = "context-management-2025-06-27";
-const structuredOutputsBeta = "structured-outputs-2025-12-15";
-const thinkingTokenCountBeta = "thinking-token-count-2026-05-13";
-const fallbackCreditBeta = "fallback-credit-2026-06-01";
-const claudeCodeUtilityBetaDefaults = [
-	oauthAuthBeta,
-	"interleaved-thinking-2025-05-14",
-	thinkingTokenCountBeta,
-	contextManagementBeta,
-	"prompt-caching-scope-2026-01-05",
-	structuredOutputsBeta
-];
-const claudeCodeAgentBetaDefaults = [
-	"claude-code-20250219",
-	oauthAuthBeta,
-	"interleaved-thinking-2025-05-14",
-	thinkingTokenCountBeta,
-	contextManagementBeta,
-	"prompt-caching-scope-2026-01-05",
-	midConversationSystemBeta
-];
-const extendedCacheTtlBeta = "extended-cache-ttl-2025-04-11";
-const fineGrainedToolStreamingBeta = "fine-grained-tool-streaming-2025-05-14";
-const interleavedThinkingBeta = "interleaved-thinking-2025-05-14";
-const fastModeBeta = "fast-mode-2026-02-01";
-const taskBudgetBeta = "task-budgets-2026-03-13";
-const effortBeta = "effort-2025-11-24";
-const serverSideFallbackBeta = "server-side-fallback-2026-06-01";
-function resolveAnthropicControlBetas(model, prefixMismatchBehavior) {
-	const betas = [];
-	if (prefixMismatchBehavior) betas.push(THINKING_BINDING_CONTROLS_BETA);
-	if (model.compat.supportsTurnScopedSystem) betas.push(midConversationSystemClearAtBeta);
-	if (model.compat.supportsMidConversationToolChanges) betas.push(midConversationToolChangesBeta);
-	if (model.compat.supportsPerMessageEffort) betas.push(midConversationOutputConfigBeta);
-	return betas;
-}
-function buildClaudeCodeBetas({ agentRequest, thinkingRequest, disableStrictTools = false, supportsContextManagement = true }) {
-	if (!agentRequest && !disableStrictTools && supportsContextManagement) return claudeCodeUtilityBetaDefaults;
-	const betas = [];
-	for (const beta of agentRequest ? claudeCodeAgentBetaDefaults : claudeCodeUtilityBetaDefaults) {
-		if (disableStrictTools && beta === structuredOutputsBeta) continue;
-		if (!supportsContextManagement && beta === contextManagementBeta) continue;
-		betas.push(beta);
-	}
-	if (!agentRequest) return betas;
-	if (thinkingRequest) betas.push(effortBeta);
-	betas.push(fallbackCreditBeta);
-	return betas;
-}
-function isClaudeCodeClientUserAgent(userAgent) {
-	if (!userAgent) return false;
-	return userAgent.toLowerCase().startsWith("claude-cli");
-}
-const sharedHeaders = {
-	"Accept-Encoding": "gzip, deflate, br, zstd",
-	Connection: "keep-alive",
-	"Content-Type": "application/json",
-	"anthropic-version": "2023-06-01",
-	"anthropic-dangerous-direct-browser-access": "true",
-	"x-app": "cli"
-};
-function buildAnthropicHeaders(options) {
-	const oauthToken = options.isOAuth ?? isAnthropicOAuthToken(options.apiKey);
-	const extraBetas = options.extraBetas ?? [];
-	const stream = options.stream ?? false;
-	const incomingUserAgent = getHeaderCaseInsensitive(options.modelHeaders, "User-Agent");
-	const incomingAuthorization = getHeaderCaseInsensitive(options.modelHeaders, "Authorization");
-	const incomingApiKey = getHeaderCaseInsensitive(options.modelHeaders, "X-Api-Key");
-	const betaHeader = buildBetaHeader(options.claudeCodeBetas ?? (oauthToken ? buildClaudeCodeBetas({
-		agentRequest: true,
-		thinkingRequest: true
-	}) : []), extraBetas);
-	const acceptHeader = oauthToken ? "application/json" : stream ? "text/event-stream" : "application/json";
-	const isCloudflare = options.isCloudflareAiGateway ?? false;
-	const honorAuthorization = !oauthToken && !isCloudflare;
-	const allowAnthropicHeaderOverrides = oauthToken && options.allowAnthropicHeaderOverrides === true && !isCloudflare && !isOfficialAnthropicApiUrl(options.baseUrl);
-	const honorApiKey = !isCloudflare;
-	const modelHeaders = {};
-	const anthropicHeaderOverrides = {};
-	const filteredEnforcedKeys = [];
-	const headerSource = options.modelHeaders;
-	if (headerSource) for (const key in headerSource) {
-		const value = headerSource[key];
-		const lowerKey = key.toLowerCase();
-		if (enforcedHeaderKeys.has(lowerKey)) {
-			if (allowAnthropicHeaderOverrides && overridableAnthropicHeaderKeys.has(lowerKey)) {
-				anthropicHeaderOverrides[key] = value;
-				continue;
-			}
-			if (lowerKey === "user-agent") continue;
-			if (lowerKey === "authorization" && honorAuthorization) continue;
-			if (lowerKey === "x-api-key" && honorApiKey) continue;
-			filteredEnforcedKeys.push(key);
-			continue;
-		}
-		modelHeaders[key] = value;
-	}
-	if (filteredEnforcedKeys.length > 0) debug("anthropic: ignoring caller-supplied enforced headers", { headers: filteredEnforcedKeys });
-	if (isCloudflare) return {
-		...modelHeaders,
-		Accept: acceptHeader,
-		...sharedHeaders,
-		...incomingUserAgent ? { "User-Agent": incomingUserAgent } : {},
-		...betaHeader ? { "anthropic-beta": betaHeader } : {},
-		"cf-aig-authorization": `Bearer ${options.apiKey}`
-	};
-	if (oauthToken) {
-		const userAgent = isClaudeCodeClientUserAgent(incomingUserAgent) ? incomingUserAgent : claudeCodeUserAgent;
-		const headers = {
-			...modelHeaders,
-			Accept: acceptHeader,
-			"Content-Type": "application/json",
-			"User-Agent": userAgent,
-			...options.claudeCodeSessionId ? { "X-Claude-Code-Session-Id": options.claudeCodeSessionId } : {},
-			...claudeCodeHeaders,
-			...betaHeader ? { "anthropic-beta": betaHeader } : {},
-			"anthropic-dangerous-direct-browser-access": "true",
-			"anthropic-version": "2023-06-01",
-			Authorization: `Bearer ${options.apiKey}`,
-			"x-app": "cli",
-			Connection: "keep-alive",
-			"Accept-Encoding": "gzip, deflate, br, zstd",
-			...incomingApiKey ? { "X-Api-Key": incomingApiKey } : {}
-		};
-		return allowAnthropicHeaderOverrides ? mergeHeaders(headers, anthropicHeaderOverrides) : headers;
-	} else if (!isOfficialAnthropicApiUrl(options.baseUrl)) return {
-		...modelHeaders,
-		Accept: acceptHeader,
-		Authorization: incomingAuthorization ?? `Bearer ${options.apiKey}`,
-		...sharedHeaders,
-		...incomingUserAgent ? { "User-Agent": incomingUserAgent } : {},
-		...betaHeader ? { "anthropic-beta": betaHeader } : {},
-		...incomingApiKey ? { "X-Api-Key": incomingApiKey } : {}
-	};
-	else return {
-		...modelHeaders,
-		Accept: acceptHeader,
-		...sharedHeaders,
-		...incomingUserAgent ? { "User-Agent": incomingUserAgent } : {},
-		...betaHeader ? { "anthropic-beta": betaHeader } : {},
-		...incomingAuthorization ? { Authorization: incomingAuthorization } : {},
-		"X-Api-Key": incomingApiKey ?? options.apiKey
-	};
-}
-function normalizeAnthropicImageMediaType(mimeType) {
-	const normalized = mimeType.trim().toLowerCase();
-	if (normalized === "image/jpg") return "image/jpeg";
-	if (normalized === "image/jpeg" || normalized === "image/png" || normalized === "image/gif" || normalized === "image/webp") return normalized;
-}
-function cloneAnthropicCacheControl(cacheControl) {
-	return { ...cacheControl };
-}
-const ANTHROPIC_STOP_SEQUENCES_MAX = 4;
-let warnedStopSequencesTrim = false;
-const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
-function createAnthropicControlState() {
-	return {
-		declaredTools: void 0,
-		activeToolNames: /* @__PURE__ */ new Set(),
-		stableSystemBlocks: void 0,
-		systemFingerprint: void 0,
-		controlTransitions: [],
-		baseEffort: void 0,
-		baseEffortWire: void 0,
-		currentEffort: void 0
-	};
-}
-function createAnthropicProviderSessionState() {
-	const state = {
-		strictToolsDisabled: false,
-		fastModeDisabled: false,
-		replayUnsignedThinkingDisabled: false,
-		prefixDroppedThinkingBlocks: /* @__PURE__ */ new Set(),
-		controlStates: /* @__PURE__ */ new Map(),
-		close: () => {
-			state.strictToolsDisabled = false;
-			state.fastModeDisabled = false;
-			state.replayUnsignedThinkingDisabled = false;
-			state.prefixDroppedThinkingBlocks.clear();
-			state.controlStates.clear();
-		}
-	};
-	return state;
-}
-/**
-* Key the sticky strict-tools / fast-mode learning per endpoint+model. A
-* grammar-too-large 400 or a fast-mode rejection is specific to the model (its
-* tool grammar / entitlement) and the endpoint (direct Anthropic vs a gateway /
-* Foundry / Bedrock proxy), so it MUST NOT bleed onto unrelated anthropic-messages
-* requests in the same session. NUL separates the two components so neither can
-* forge the boundary.
-*/
-function anthropicProviderSessionStateKey(baseUrl, modelId) {
-	return `${ANTHROPIC_PROVIDER_SESSION_STATE_KEY}:${baseUrl}\u0000${modelId}`;
-}
-function getAnthropicProviderSessionState(providerSessionState, baseUrl, modelId) {
-	if (!providerSessionState) return void 0;
-	const key = anthropicProviderSessionStateKey(baseUrl, modelId);
-	const existing = providerSessionState.get(key);
-	if (existing) {
-		existing.prefixDroppedThinkingBlocks ??= /* @__PURE__ */ new Set();
-		existing.controlStates ??= /* @__PURE__ */ new Map();
-		return existing;
-	}
-	const created = createAnthropicProviderSessionState();
-	providerSessionState.set(key, created);
-	return created;
-}
-function hasStrictAnthropicTools(params) {
-	return params.tools?.some((tool) => tool.strict === true) ?? false;
-}
-function dropAnthropicFastMode(params) {
-	delete params.speed;
-}
-function dropAnthropicStrictTools(params) {
-	if (!params.tools) return;
-	for (const tool of params.tools) delete tool.strict;
-}
-function getCacheControl(model, cacheRetention) {
-	const retention = resolveCacheRetention(cacheRetention, "short");
-	if (retention === "none") return { retention };
-	const ttl = retention === "long" && model.compat.supportsLongCacheRetention ? "1h" : void 0;
-	return {
-		retention,
-		cacheControl: {
-			type: "ephemeral",
-			...ttl && { ttl }
-		}
-	};
-}
-/** Maps Node's platform identifier to the Stainless wire value. */
-function mapStainlessOs(platform) {
-	switch (platform.toLowerCase()) {
-		case "darwin": return "MacOS";
-		case "windows":
-		case "win32": return "Windows";
-		case "linux": return "Linux";
-		case "freebsd": return "FreeBSD";
-		default: return `Other::${platform.toLowerCase()}`;
-	}
-}
-/** Maps Node's architecture identifier to the Stainless wire value. */
-function mapStainlessArch(arch) {
-	switch (arch.toLowerCase()) {
-		case "amd64":
-		case "x64": return "x64";
-		case "arm64":
-		case "aarch64": return "arm64";
-		case "386":
-		case "x86":
-		case "ia32": return "x86";
-		default: return `other::${arch.toLowerCase()}`;
-	}
-}
-/** Static headers emitted by Claude Code's CLI runtime. */
-const claudeCodeHeaders = {
-	"X-Stainless-Arch": mapStainlessArch(process.arch),
-	"X-Stainless-Lang": "js",
-	"X-Stainless-OS": mapStainlessOs(process.platform),
-	"X-Stainless-Package-Version": claudeCodeSdkVersion,
-	"X-Stainless-Retry-Count": "0",
-	"X-Stainless-Runtime": "node",
-	"X-Stainless-Runtime-Version": "v26.3.0",
-	"X-Stainless-Timeout": "600"
-};
-const enforcedHeaderKeys = new Set([
-	...Object.keys(claudeCodeHeaders),
-	"Accept",
-	"Accept-Encoding",
-	"Connection",
-	"Content-Type",
-	"anthropic-version",
-	"anthropic-dangerous-direct-browser-access",
-	"anthropic-beta",
-	"User-Agent",
-	"x-app",
-	"Authorization",
-	"X-Api-Key",
-	"X-Claude-Code-Session-Id",
-	"x-client-request-id",
-	"cf-aig-authorization"
-].map((key) => key.toLowerCase()));
-const overridableAnthropicHeaderKeys = new Set([
-	...Object.keys(claudeCodeHeaders),
-	"anthropic-beta",
-	"User-Agent",
-	"x-app"
-].map((key) => key.toLowerCase()));
-const CLAUDE_BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
-function createClaudeBillingHeader(firstUserMessageText) {
-	const k = [
-		4,
-		7,
-		20
-	].map((i) => firstUserMessageText[i] ?? "0").join("");
-	const versionSuffix = nodeCrypto.createHash("sha256").update(`59cf53e54c78${k}${claudeCodeVersion}`).digest("hex").slice(0, 3);
-	return `${CLAUDE_BILLING_HEADER_PREFIX} cc_version=${claudeCodeVersion}.${versionSuffix}; cc_entrypoint=cli; ${CCH_PLACEHOLDER_STR};`;
-}
-const CCH_SEED = 5577024349156291176n;
-const CCH_PLACEHOLDER_STR = "cch=00000";
-const cchEncoder = new TextEncoder();
-const CCH_PLACEHOLDER = cchEncoder.encode(CCH_PLACEHOLDER_STR);
-const BILLING_SYSTEM_MARKER = cchEncoder.encode(`"system":[{"type":"text","text":"${CLAUDE_BILLING_HEADER_PREFIX}`);
-const CCH_BILLING_SEARCH_WINDOW = 150;
-function patchCch(body) {
-	const view = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-	const markerIdx = view.indexOf(BILLING_SYSTEM_MARKER);
-	if (markerIdx === -1) return "no-billing-header";
-	const searchFrom = markerIdx + BILLING_SYSTEM_MARKER.length;
-	const idx = view.indexOf(CCH_PLACEHOLDER, searchFrom);
-	if (idx === -1 || idx - searchFrom > CCH_BILLING_SEARCH_WINDOW) return "unanchored";
-	const cch = (Bun.hash.xxHash64(body, CCH_SEED) & 1048575n).toString(16).padStart(5, "0");
-	for (let i = 0; i < 5; i++) body[idx + 4 + i] = cch.charCodeAt(i);
-	return "patched";
-}
-/**
-* Wraps a fetch implementation to patch the Claude Code billing-header `cch`
-* attestation into outgoing request bodies. Bodies without the placeholder
-* pass through untouched, so installing it on every OAuth flow is safe.
-*/
-function wrapFetchForCch(base) {
-	return (input, init) => {
-		if (init?.body && typeof init.body === "string" && init.body.includes(CCH_PLACEHOLDER_STR)) {
-			const encoded = cchEncoder.encode(init.body);
-			if (patchCch(encoded) === "unanchored") warn("anthropic: cch billing placeholder present but not patched; sending unattested request");
-			return base(input, {
-				...init,
-				body: encoded
-			});
-		}
-		return base(input, init);
-	};
-}
-const CLAUDE_CLOAKING_USER_ID_REGEX = /^user_[0-9a-fA-F]{64}_account_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}_session_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function isClaudeCloakingUserId(userId) {
-	return CLAUDE_CLOAKING_USER_ID_REGEX.test(userId);
-}
-/**
-* Real Claude Code sends `metadata.user_id` as a JSON-stringified object of the
-* shape `{ device_id, account_uuid, session_id, ...extra }` (see
-* services/api/claude.ts → getAPIMetadata). Accept that shape so callers that
-* supply a stable `session_id` aren't silently overwritten with fresh entropy
-* on every request, which would inflate the backend session count.
-*/
-function isClaudeJsonUserId(userId) {
-	if (userId.length === 0 || userId[0] !== "{") return false;
-	let parsed;
-	try {
-		parsed = JSON.parse(userId);
-	} catch {
-		return false;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
-	const obj = parsed;
-	return typeof obj.session_id === "string" && obj.session_id.length > 0;
-}
-function extractClaudeMetadataSessionId(userId) {
-	if (typeof userId !== "string") return void 0;
-	if (isClaudeCloakingUserId(userId)) return userId.slice(userId.lastIndexOf("_session_") + 9);
-	if (userId.length === 0 || userId[0] !== "{") return void 0;
-	let parsed;
-	try {
-		parsed = JSON.parse(userId);
-	} catch {
-		return;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
-	const sessionId = parsed.session_id;
-	return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : void 0;
-}
-const CLAUDE_DEVICE_ID_INSTALL_HASH_DOMAIN = "omp-claude-device-id-v1:";
-const CLAUDE_DEVICE_ID_ACCOUNT_HASH_DOMAIN = "omp-claude-device-id-v2";
-function deriveClaudeDeviceId(installId, accountId) {
-	const hash = nodeCrypto.createHash("sha256");
-	if (accountId && accountId.length > 0) return hash.update(CLAUDE_DEVICE_ID_ACCOUNT_HASH_DOMAIN).update("\0").update(installId).update("\0").update(accountId).digest("hex");
-	return hash.update(CLAUDE_DEVICE_ID_INSTALL_HASH_DOMAIN).update(installId).digest("hex");
-}
-function readMetadataString(metadata, key) {
-	const value = metadata?.[key];
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function readAnthropicMetadataAccountId(metadata) {
-	return readMetadataString(metadata, "account_uuid") ?? readMetadataString(metadata, "accountId") ?? readMetadataString(metadata, "account_id");
-}
-function deriveClaudeDeviceIdFromInstallId(accountId) {
-	return deriveClaudeDeviceId(getInstallId(), accountId);
-}
-function generateClaudeJsonUserId(sessionId, accountId) {
-	const userId = {
-		device_id: deriveClaudeDeviceIdFromInstallId(accountId),
-		session_id: sessionId ?? nodeCrypto.randomUUID().toLowerCase()
-	};
-	if (accountId && accountId.length > 0) userId.account_uuid = accountId;
-	return JSON.stringify(userId);
-}
-/**
-* Resolve the `metadata.user_id` field for an Anthropic Messages request.
-*
-* For API-key tokens, an explicit caller-supplied `userId` is forwarded
-* verbatim and `undefined` yields no metadata. For OAuth tokens the value
-* must match the Claude Code attribution shape (`isClaudeCloakingUserId` or
-* the `{session_id, account_uuid?, device_id?}` JSON envelope) — anything
-* else is dropped and a fresh Claude-Code-style JSON id is generated from
-* `sessionId`/`accountId` so attribution stays consistent across the main
-* streaming path and provider-specific request builders (e.g. web search).
-*/
-function resolveAnthropicMetadataUserId(userId, isOAuthToken, sessionId, accountId) {
-	if (typeof userId === "string") {
-		if (!isOAuthToken || isClaudeCloakingUserId(userId) || isClaudeJsonUserId(userId)) return userId;
-	}
-	if (!isOAuthToken) return void 0;
-	return generateClaudeJsonUserId(sessionId, accountId);
-}
-const ANTHROPIC_BUILTIN_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"web_search",
-	"code_execution",
-	"text_editor",
-	"computer"
-]);
-const UMANS_WEBSEARCH_PROVIDER_HEADER = "X-Umans-Websearch-Provider";
-const UMANS_WEBSEARCH_TOOL_NAME = "web_search";
-const applyClaudeToolPrefix = (name) => {
-	if (ANTHROPIC_BUILTIN_TOOL_NAMES.has(name.toLowerCase())) return name;
-	return `_${name}`;
-};
-const stripClaudeToolPrefix = (name) => {
-	if (!name.toLowerCase().startsWith("_".toLowerCase())) return name;
-	return name.slice(1);
-};
-function normalizeUmansWebSearchProvider(value) {
-	const normalized = value?.trim().toLowerCase();
-	return normalized === "native" || normalized === "exa" ? normalized : void 0;
-}
-function getUmansWebSearchProvider(headers) {
-	const explicit = getHeaderCaseInsensitive(headers, UMANS_WEBSEARCH_PROVIDER_HEADER);
-	if (explicit !== void 0) return normalizeUmansWebSearchProvider(explicit);
-	return normalizeUmansWebSearchProvider($env.UMANS_WEBSEARCH_PROVIDER);
-}
-function isUmansAnthropicModel(model) {
-	return model.provider === "umans" || model.baseUrl.toLowerCase().includes("api.code.umans.ai");
-}
-function getUmansWebSearchHeader(model, headers) {
-	if (!isUmansAnthropicModel(model)) return void 0;
-	const provider = getUmansWebSearchProvider(headers);
-	return provider ? { [UMANS_WEBSEARCH_PROVIDER_HEADER]: provider } : void 0;
-}
-function shouldUseUmansGatewayWebSearch(name, enabled) {
-	return enabled && name.toLowerCase() === UMANS_WEBSEARCH_TOOL_NAME;
-}
-function encodeAnthropicToolName(name, isOAuthToken, escapeBuiltinToolNames, useUmansGatewayWebSearch = false) {
-	if (shouldUseUmansGatewayWebSearch(name, useUmansGatewayWebSearch)) return name;
-	if (escapeBuiltinToolNames) return `_${name}`;
-	return isOAuthToken ? applyClaudeToolPrefix(name) : name;
-}
-function decodeAnthropicToolName(name, isOAuthToken, escapeBuiltinToolNames) {
-	if (isOAuthToken || escapeBuiltinToolNames) return stripClaudeToolPrefix(name);
-	return name;
-}
-const ANTHROPIC_MANY_IMAGE_THRESHOLD = 20;
-const ANTHROPIC_MANY_IMAGE_MAX_DIMENSION = 2e3;
-function countAnthropicImageBlocks(messages) {
-	let count = 0;
-	for (const message of messages) {
-		if (message.role !== "user" && message.role !== "developer" && message.role !== "toolResult") continue;
-		if (!Array.isArray(message.content)) continue;
-		for (const block of message.content) if (block.type === "image") count++;
-	}
-	return count;
-}
-const ANTHROPIC_IMAGE_RESIZE_CONCURRENCY = 4;
-/**
-* Memoized resize results keyed on ImageContent identity. Callers keep message
-* objects stable across turns, so without this every request (and every
-* in-provider retry of a fresh turn) re-decodes and re-encodes the same
-* oversized screenshots. A cached value identical to the key means "already
-* within bounds / unresizable — skip the decode".
-*/
-const anthropicManyImageResizeCache = /* @__PURE__ */ new WeakMap();
-/**
-* Bounded-concurrency gate for image decode/encode work. The many-image path
-* fans out over every block of every message; unbounded, 100+ oversized images
-* would decode concurrently (two encode pipelines each) and spike memory by
-* gigabytes. Slots are handed off directly to the next waiter on release.
-*/
-function createResizeLimiter(limit) {
-	let active = 0;
-	const queue = [];
-	return async (fn) => {
-		if (active >= limit) {
-			const { promise, resolve } = Promise.withResolvers();
-			queue.push(resolve);
-			await promise;
-		} else active++;
-		try {
-			return await fn();
-		} finally {
-			const next = queue.shift();
-			if (next) next();
-			else active--;
-		}
-	};
-}
-async function resizeAnthropicManyImageBlock(block) {
-	try {
-		const inputBuffer = Buffer.from(block.data, "base64");
-		const { width, height } = await new Bun.Image(inputBuffer).metadata();
-		if (!width || !height) return block;
-		if (width <= ANTHROPIC_MANY_IMAGE_MAX_DIMENSION && height <= ANTHROPIC_MANY_IMAGE_MAX_DIMENSION) return block;
-		const scale = Math.min(ANTHROPIC_MANY_IMAGE_MAX_DIMENSION / width, ANTHROPIC_MANY_IMAGE_MAX_DIMENSION / height);
-		const targetWidth = Math.max(1, Math.min(ANTHROPIC_MANY_IMAGE_MAX_DIMENSION, Math.round(width * scale)));
-		const targetHeight = Math.max(1, Math.min(ANTHROPIC_MANY_IMAGE_MAX_DIMENSION, Math.round(height * scale)));
-		const [png, jpeg] = await Promise.all([new Bun.Image(inputBuffer).resize(targetWidth, targetHeight).png().bytes(), new Bun.Image(inputBuffer).resize(targetWidth, targetHeight).jpeg({ quality: 85 }).bytes()]);
-		const best = png.length <= jpeg.length ? {
-			buffer: png,
-			mimeType: "image/png"
-		} : {
-			buffer: jpeg,
-			mimeType: "image/jpeg"
-		};
-		return {
-			type: "image",
-			data: Buffer.from(best.buffer).toString("base64"),
-			mimeType: best.mimeType
-		};
-	} catch (error) {
-		warn("anthropic: failed to resize oversized image for many-image request", {
-			mimeType: block.mimeType,
-			error: error instanceof Error ? error.message : String(error)
-		});
-		return block;
-	}
-}
-async function resizeAnthropicManyImageContent(content, state, limit) {
-	let changed = false;
-	const next = await Promise.all(content.map(async (block) => {
-		if (block.type !== "image" || block.url || block.providerFile?.provider === "anthropic" && block.providerFile.id) return block;
-		let resized = anthropicManyImageResizeCache.get(block);
-		if (resized === void 0) {
-			resized = await limit(() => resizeAnthropicManyImageBlock(block));
-			anthropicManyImageResizeCache.set(block, resized);
-		}
-		if (resized !== block) {
-			changed = true;
-			state.resized++;
-		}
-		return resized;
-	}));
-	return changed ? next : content;
-}
-async function resizeAnthropicManyImageMessage(message, state, limit) {
-	if (message.role === "user" || message.role === "developer") {
-		if (!Array.isArray(message.content)) return message;
-		const content = await resizeAnthropicManyImageContent(message.content, state, limit);
-		return content === message.content ? message : {
-			...message,
-			content
-		};
-	}
-	if (message.role === "toolResult") {
-		const content = await resizeAnthropicManyImageContent(message.content, state, limit);
-		return content === message.content ? message : {
-			...message,
-			content
-		};
-	}
-	return message;
-}
-async function prepareAnthropicManyImageContext(context, supportsImages) {
-	if (!supportsImages) return context;
-	const imageCount = countAnthropicImageBlocks(context.messages);
-	if (imageCount <= ANTHROPIC_MANY_IMAGE_THRESHOLD) return context;
-	let changed = false;
-	const state = { resized: 0 };
-	const limit = createResizeLimiter(ANTHROPIC_IMAGE_RESIZE_CONCURRENCY);
-	const messages = await Promise.all(context.messages.map(async (message) => {
-		const next = await resizeAnthropicManyImageMessage(message, state, limit);
-		if (next !== message) changed = true;
-		return next;
-	}));
-	if (!changed) return context;
-	debug("anthropic: resized oversized images for many-image request", {
-		imageCount,
-		resized: state.resized,
-		maxDimension: ANTHROPIC_MANY_IMAGE_MAX_DIMENSION
-	});
-	return {
-		...context,
-		messages
-	};
-}
-/**
-* Convert content blocks to Anthropic API format
-*/
-function convertContentBlocks(content, supportsImages = true) {
-	const blocks = [];
-	let sawText = false;
-	let sawImage = false;
-	for (const block of content) {
-		if (block.type === "text") {
-			const text = block.text.toWellFormed();
-			if (text.trim().length === 0) continue;
-			sawText = true;
-			blocks.push({
-				type: "text",
-				text
-			});
-			continue;
-		}
-		if (!supportsImages) {
-			blocks.push({
-				type: "text",
-				text: NON_VISION_IMAGE_PLACEHOLDER
-			});
-			continue;
-		}
-		let source;
-		if (block.providerFile?.provider === "anthropic" && block.providerFile.id) source = {
-			type: "file",
-			file_id: block.providerFile.id
-		};
-		else if (block.url) source = {
-			type: "url",
-			url: block.url
-		};
-		else {
-			const mediaType = normalizeAnthropicImageMediaType(block.mimeType);
-			if (!mediaType) {
-				blocks.push({
-					type: "text",
-					text: `[unsupported image: ${block.mimeType}]`
-				});
-				continue;
-			}
-			source = {
-				type: "base64",
-				media_type: mediaType,
-				data: block.data
-			};
-		}
-		sawImage = true;
-		blocks.push({
-			type: "image",
-			source
-		});
-	}
-	if (!supportsImages) return blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n").toWellFormed();
-	if (sawImage && !sawText) blocks.unshift({
-		type: "text",
-		text: "(see attached image)"
-	});
-	return blocks;
-}
-const CLAUDE_CODE_TLS_CIPHERS = tls.DEFAULT_CIPHERS;
-const foundryTlsOptionsCache = /* @__PURE__ */ new Map();
-function foundryTlsCacheKeyComponent(value) {
-	if (!value) return null;
-	const trimmed = value.trim();
-	if (trimmed && !trimmed.includes("-----BEGIN") && looksLikeFilePath(trimmed)) try {
-		return `${trimmed}@${fs.statSync(trimmed).mtimeMs}`;
-	} catch {
-		return trimmed;
-	}
-	return value;
-}
-function foundryTlsOptionsCacheKey() {
-	return JSON.stringify([
-		foundryTlsCacheKeyComponent($env.NODE_EXTRA_CA_CERTS),
-		foundryTlsCacheKeyComponent($env.CLAUDE_CODE_CLIENT_CERT),
-		foundryTlsCacheKeyComponent($env.CLAUDE_CODE_CLIENT_KEY)
-	]);
-}
-function resolveAnthropicBaseUrl(model, apiKey) {
-	if (model.provider === "github-copilot") return normalizeAnthropicBaseUrl(resolveGitHubCopilotBaseUrl(model.baseUrl, apiKey) ?? model.baseUrl);
-	if (model.provider === "anthropic" && isFoundryEnabled()) {
-		const foundryBaseUrl = normalizeAnthropicBaseUrl($env.FOUNDRY_BASE_URL);
-		if (foundryBaseUrl) return foundryBaseUrl;
-	}
-	if (model.provider === "anthropic") {
-		const configured = normalizeAnthropicBaseUrl(model.baseUrl);
-		if (configured && !isOfficialAnthropicApiUrl(configured)) return configured;
-		return normalizeAnthropicBaseUrl($env.ANTHROPIC_BASE_URL) ?? configured ?? "https://api.anthropic.com";
-	}
-	return normalizeAnthropicBaseUrl(model.baseUrl);
-}
-function resolveEagerToolInputStreamingSupport(model, effectiveBaseUrl) {
-	if (!model.compat.supportsEagerToolInputStreaming) return false;
-	if (isOfficialAnthropicApiUrl(effectiveBaseUrl)) return true;
-	return !model.compat.officialEndpoint;
-}
-function parseAnthropicCustomHeaders(rawHeaders) {
-	const source = rawHeaders?.trim();
-	if (!source) return void 0;
-	const parsed = {};
-	for (const token of source.split(/\r?\n|,/)) {
-		const entry = token.trim();
-		if (!entry) continue;
-		const separatorIndex = entry.indexOf(":");
-		if (separatorIndex <= 0) continue;
-		const key = entry.slice(0, separatorIndex).trim();
-		const value = entry.slice(separatorIndex + 1).trim();
-		if (!key || !value) continue;
-		parsed[key] = value;
-	}
-	return Object.keys(parsed).length > 0 ? parsed : void 0;
-}
-/**
-* Returns env-supplied custom headers (`ANTHROPIC_CUSTOM_HEADERS`) when they
-* should be forwarded to the upstream endpoint.
-*
-* Foundry mode forwards them unconditionally. Outside Foundry, they're applied
-* only when the configured base URL is a non-Anthropic host — i.e. an
-* enterprise/corporate gateway that may require its own proprietary auth
-* header. Stock `api.anthropic.com` would reject unknown headers, so they're
-* omitted there.
-*/
-function resolveAnthropicCustomHeadersForBaseUrl(baseUrl) {
-	if (!isFoundryEnabled() && isOfficialAnthropicApiUrl(baseUrl)) return void 0;
-	return parseAnthropicCustomHeaders($env.ANTHROPIC_CUSTOM_HEADERS);
-}
-function resolveAnthropicCustomHeaders(model, baseUrl) {
-	if (model.provider !== "anthropic") return void 0;
-	return resolveAnthropicCustomHeadersForBaseUrl(baseUrl);
-}
-function looksLikeFilePath(value) {
-	return value.includes("/") || value.includes("\\") || /\.(pem|crt|cer|key)$/i.test(value);
-}
-function resolvePemValue(value, name) {
-	const trimmed = value?.trim();
-	if (!trimmed) return void 0;
-	const inline = trimmed.replace(/\\n/g, "\n");
-	if (inline.includes("-----BEGIN")) return inline;
-	if (looksLikeFilePath(trimmed)) try {
-		return fs.readFileSync(trimmed, "utf8");
-	} catch (error) {
-		if (isEnoent(error)) throw new ValidationError(`${name} path does not exist: ${trimmed}`);
-		throw error;
-	}
-	return inline;
-}
-function resolveFoundryTlsOptions(model) {
-	if (model.provider !== "anthropic") return void 0;
-	if (!isFoundryEnabled()) return void 0;
-	const cacheKey = foundryTlsOptionsCacheKey();
-	if (foundryTlsOptionsCache.has(cacheKey)) return foundryTlsOptionsCache.get(cacheKey);
-	const ca = resolvePemValue($env.NODE_EXTRA_CA_CERTS, "NODE_EXTRA_CA_CERTS");
-	const cert = resolvePemValue($env.CLAUDE_CODE_CLIENT_CERT, "CLAUDE_CODE_CLIENT_CERT");
-	const key = resolvePemValue($env.CLAUDE_CODE_CLIENT_KEY, "CLAUDE_CODE_CLIENT_KEY");
-	if (cert && !key || !cert && key) throw new ConfigurationError("Both CLAUDE_CODE_CLIENT_CERT and CLAUDE_CODE_CLIENT_KEY must be set for mTLS.");
-	const options = {};
-	if (ca) options.ca = [...tls.rootCertificates, ca];
-	if (cert) options.cert = cert;
-	if (key) options.key = key;
-	const resolved = Object.keys(options).length > 0 ? options : void 0;
-	foundryTlsOptionsCache.set(cacheKey, resolved);
-	return resolved;
-}
-function buildClaudeCodeTlsFetchOptions(model, baseUrl) {
-	if (model.provider !== "anthropic") return void 0;
-	if (!baseUrl) return void 0;
-	let serverName;
-	try {
-		serverName = new URL(baseUrl).hostname;
-	} catch {
-		return;
-	}
-	if (!serverName) return void 0;
-	const foundryTlsOptions = resolveFoundryTlsOptions(model);
-	return { tls: {
-		rejectUnauthorized: true,
-		serverName,
-		...CLAUDE_CODE_TLS_CIPHERS ? { ciphers: CLAUDE_CODE_TLS_CIPHERS } : {},
-		...foundryTlsOptions
-	} };
-}
-function mergeHeaders(...headerSources) {
-	const merged = {};
-	const keyByLower = /* @__PURE__ */ new Map();
-	for (const headers of headerSources) {
-		if (!headers) continue;
-		for (const [key, value] of Object.entries(headers)) {
-			const lower = key.toLowerCase();
-			const existing = keyByLower.get(lower);
-			if (existing !== void 0 && existing !== key) delete merged[existing];
-			keyByLower.set(lower, key);
-			merged[key] = value;
-		}
-	}
-	return merged;
-}
-const ANTHROPIC_MESSAGE_EVENTS = /* @__PURE__ */ new Set([
-	"message_start",
-	"message_delta",
-	"message_stop",
-	"content_block_start",
-	"content_block_delta",
-	"content_block_stop"
-]);
-const ANTHROPIC_PING_EVENT = { type: "ping" };
-/**
-* In-stream `error` SSE frames carry an Anthropic error envelope:
-* `{"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}`.
-* Surface the structured type + message instead of the raw JSON blob; the
-* error type token (e.g. `overloaded_error`, `rate_limit_error`) is kept in
-* the message so `isProviderRetryableError`'s classification keys off the
-* structured type rather than incidental JSON substrings.
-*/
-function createAnthropicSseStreamError(data) {
-	try {
-		const parsed = JSON.parse(data);
-		const errorType = typeof parsed?.error?.type === "string" ? parsed.error.type : void 0;
-		const message = typeof parsed?.error?.message === "string" ? parsed.error.message : void 0;
-		if (message) return new ProviderResponseError(errorType ? `Anthropic stream error (${errorType}): ${message}` : `Anthropic stream error: ${message}`, {
-			provider: "anthropic",
-			kind: "output"
-		});
-	} catch {}
-	return new ProviderResponseError(data, {
-		provider: "anthropic",
-		kind: "output"
-	});
-}
-async function* iterateAnthropicEvents(response, signal, onSseEvent) {
-	if (!response.body) throw new AnthropicStreamEnvelopeError("Attempted to iterate over an Anthropic response with no body");
-	let sawMessageStart = false;
-	let sawMessageEnd = false;
-	for await (const sse of readSseEvents(response.body, signal)) {
-		notifyRawSseEvent(onSseEvent, sse);
-		if (sse.event === "error") throw createAnthropicSseStreamError(sse.data);
-		if (sse.event === "ping") {
-			yield ANTHROPIC_PING_EVENT;
-			continue;
-		}
-		if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) continue;
-		try {
-			const event = JSON.parse(sse.data);
-			if (event.type !== sse.event) reportAnthropicEnvelopeAnomaly(`event type ${event.type} does not match SSE event ${sse.event}`);
-			if (event.type === "message_start") sawMessageStart = true;
-			else if (event.type === "message_stop") sawMessageEnd = true;
-			yield event;
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			reportAnthropicEnvelopeAnomaly(`could not parse SSE event ${sse.event}: ${message}; skipping frame; data=${sse.data}`);
-		}
-	}
-	if (sawMessageStart && !sawMessageEnd && !signal?.aborted) reportAnthropicEnvelopeAnomaly("stream ended before message_stop");
-}
-function hasAnthropicRawResponseRequest(request) {
-	return isRecord(request) && typeof request.asResponse === "function";
-}
-function hasAnthropicStreamWithResponseRequest(request) {
-	return isRecord(request) && typeof request.withResponse === "function";
-}
-async function getAnthropicStreamResponse(request, signal, onSseEvent) {
-	if (hasAnthropicRawResponseRequest(request)) {
-		const response = await request.asResponse();
-		return {
-			events: iterateAnthropicEvents(response, signal, onSseEvent),
-			response,
-			requestId: response.headers.get("request-id"),
-			recordsRawSseEvents: true
-		};
-	}
-	if (hasAnthropicStreamWithResponseRequest(request)) {
-		const { data, response, request_id } = await request.withResponse();
-		return {
-			events: data,
-			response,
-			requestId: request_id,
-			recordsRawSseEvents: false
-		};
-	}
-	throw new AnthropicStreamEnvelopeError("Anthropic SDK request did not expose a stream response");
-}
-async function* observeDecodedAnthropicSdkEvents(events, observer) {
-	for await (const event of events) {
-		const data = JSON.stringify(event);
-		notifyRawSseEvent(observer, {
-			event: event.type,
-			data,
-			raw: [`event: ${event.type}`, `data: ${data}`]
-		});
-		yield event;
-	}
-}
-const PROVIDER_MAX_RETRIES = 10;
-/**
-* How long `ping` keepalives may keep extending the idle deadline without any
-* semantic stream progress, as a multiple of the idle timeout. Anthropic pings
-* across legitimate generation gaps, so pings count as liveness — but a wedged
-* upstream that pings forever while producing no events must eventually trip
-* the idle watchdog instead of hanging an active tool-call stream without a
-* recovery path (#4900).
-*/
-const PING_PROGRESS_MAX_IDLE_MULTIPLIER = 3;
-/**
-* Log a malformed-stream-envelope anomaly without aborting the turn. The strict
-* parser would `throw new AnthropicStreamEnvelopeError(...)` here; we instead
-* surface a warning and let the caller skip the offending event (or finalize what
-* already streamed) so a non-conforming endpoint degrades to best-effort content
-* rather than failing the request.
-*/
-function reportAnthropicEnvelopeAnomaly(detail) {
-	warn(`anthropic: ignoring malformed stream envelope: ${detail}`);
-}
-function shouldIgnoreAnthropicPreambleEvent(eventType) {
-	if (typeof eventType !== "string") return false;
-	if (eventType === "ping") return true;
-	return !ANTHROPIC_MESSAGE_EVENTS.has(eventType);
-}
-const THINKING_ENVELOPE_OPEN = "<thinking>";
-const THINKING_ENVELOPE_CLOSE = "</thinking>";
-function unwrapAnthropicThinkingEnvelope(text) {
-	let current = text.trim();
-	let stripped = false;
-	while (current.startsWith(THINKING_ENVELOPE_OPEN) && current.endsWith(THINKING_ENVELOPE_CLOSE)) {
-		current = current.slice(10, current.length - 11).trim();
-		stripped = true;
-	}
-	return stripped ? current : void 0;
-}
-function createEmptyUsage(premiumRequests) {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		...premiumRequests === void 0 ? {} : { premiumRequests },
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-}
-/**
-* Capture Anthropic's optional cache-creation TTL breakdown and server-tool-use
-* counters into the harness Usage shape. Omitted/null fields are no-ops; explicit
-* zero-valued objects clear prior extras from earlier stream usage snapshots.
-*/
-function applyAnthropicUsageExtras(usage, source) {
-	const cacheCreation = source.cache_creation;
-	if (cacheCreation != null) {
-		const fiveMinute = cacheCreation.ephemeral_5m_input_tokens ?? 0;
-		const oneHour = cacheCreation.ephemeral_1h_input_tokens ?? 0;
-		if (fiveMinute > 0 || oneHour > 0) usage.cttl = {
-			...fiveMinute > 0 ? { ephemeral5m: fiveMinute } : {},
-			...oneHour > 0 ? { ephemeral1h: oneHour } : {}
-		};
-		else delete usage.cttl;
-	}
-	const serverToolUse = source.server_tool_use;
-	if (serverToolUse != null) {
-		const webSearch = serverToolUse.web_search_requests ?? 0;
-		const webFetch = serverToolUse.web_fetch_requests ?? 0;
-		if (webSearch > 0 || webFetch > 0) usage.server = {
-			...webSearch > 0 ? { webSearch } : {},
-			...webFetch > 0 ? { webFetch } : {}
-		};
-		else delete usage.server;
-	}
-}
-function parseAnthropicWireUsage(value) {
-	if (!isRecord(value)) return void 0;
-	const cacheCreation = isRecord(value.cache_creation) ? {
-		...typeof value.cache_creation.ephemeral_5m_input_tokens === "number" ? { ephemeral_5m_input_tokens: value.cache_creation.ephemeral_5m_input_tokens } : {},
-		...typeof value.cache_creation.ephemeral_1h_input_tokens === "number" ? { ephemeral_1h_input_tokens: value.cache_creation.ephemeral_1h_input_tokens } : {}
-	} : void 0;
-	return {
-		...typeof value.input_tokens === "number" ? { input_tokens: value.input_tokens } : {},
-		...typeof value.output_tokens === "number" ? { output_tokens: value.output_tokens } : {},
-		...typeof value.cache_read_input_tokens === "number" ? { cache_read_input_tokens: value.cache_read_input_tokens } : {},
-		...typeof value.cache_creation_input_tokens === "number" ? { cache_creation_input_tokens: value.cache_creation_input_tokens } : {},
-		...cacheCreation === void 0 ? {} : { cache_creation: cacheCreation }
-	};
-}
-function parseAnthropicFallbackWireBlock(value) {
-	if (!isRecord(value) || value.type !== "fallback") return void 0;
-	const from = isRecord(value.from) && typeof value.from.model === "string" ? value.from.model : void 0;
-	const to = isRecord(value.to) && typeof value.to.model === "string" ? value.to.model : void 0;
-	if (!from?.trim() || !to?.trim()) return void 0;
-	return {
-		type: "fallback",
-		from: { model: from },
-		to: { model: to }
-	};
-}
-/**
-* The definitive "served by fallback" signal per Anthropic's fallback
-* billing cookbook (§4): a `fallback_message` iteration in `usage.iterations`.
-* Any other iteration type is per-attempt bookkeeping for the requested model
-* (including its dated snapshot alias) and MUST NOT retag the assistant turn.
-*/
-function fallbackServedModelFromUsage(source) {
-	const iterations = source.iterations ?? [];
-	for (let index = iterations.length - 1; index >= 0; index -= 1) {
-		const iteration = iterations[index];
-		if (iteration?.type === "fallback_message" && iteration.model?.trim()) return iteration.model;
-	}
-}
-/**
-* Price a fallback turn per the fallback billing cookbook §4:
-*   • A pre-served attempt with zero output/cache-creation is not billed
-*     (waived classifier block); its iteration is skipped.
-*   • Mid-stream refusals bill their attempting model's input+output at
-*     that model's normal rates.
-*   • The `fallback_message` attempt's input tokens are rebilled at the
-*     served model's cache-read rate (fallback credit — 10% of base input).
-*
-* Top-level `usage.input/output/cacheRead/cacheWrite` stay Anthropic's raw
-* served-attempt counts; `usage.cost` reflects the per-iteration attributed
-* total. Non-fallback turns skip this path entirely and use the requested
-* model at the normal `calculateCost` call.
-*/
-/**
-* Resolve a served/iteration model id to its bundled catalog entry when
-* possible so the per-iteration cost uses the served model's pricing
-* (e.g. Opus 4.8 rates for a Fable→Opus fallback). Falls back to
-* `requestModel` when the id is empty, matches the request, or the
-* catalog has no entry under it — the caller keeps the requested-model
-* pricing as the safe default and logs at the source.
-*/
-function resolveIterationModel(requestModel, iterationModelId) {
-	const id = iterationModelId?.trim();
-	if (!id || id === requestModel.id) return requestModel;
-	if (requestModel.provider === "anthropic") {
-		const bundled = getBundledModel("anthropic", id);
-		if (bundled?.api === "anthropic-messages") return bundled;
-	}
-	return requestModel;
-}
-function calculateFallbackTurnCost(requestModel, usage, source, timestamp) {
-	const iterations = source.iterations ?? [];
-	if (iterations.length === 0) return false;
-	const cost = {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		total: 0
-	};
-	const hasFallbackMessage = iterations.some((iter) => iter.type === "fallback_message");
-	let applied = false;
-	for (const iteration of iterations) {
-		const inputTokens = iteration.input_tokens ?? 0;
-		const outputTokens = iteration.output_tokens ?? 0;
-		const cacheReadTokens = iteration.cache_read_input_tokens ?? 0;
-		const cacheWriteTokens = iteration.cache_creation_input_tokens ?? 0;
-		const isFallback = iteration.type === "fallback_message";
-		if (hasFallbackMessage && !isFallback && outputTokens === 0 && cacheWriteTokens === 0) continue;
-		const iterationUsage = createEmptyUsage();
-		if (isFallback) {
-			iterationUsage.input = 0;
-			iterationUsage.cacheRead = cacheReadTokens + inputTokens;
-		} else {
-			iterationUsage.input = inputTokens;
-			iterationUsage.cacheRead = cacheReadTokens;
-		}
-		iterationUsage.output = outputTokens;
-		iterationUsage.cacheWrite = cacheWriteTokens;
-		iterationUsage.totalTokens = iterationUsage.input + iterationUsage.output + iterationUsage.cacheRead + iterationUsage.cacheWrite;
-		calculateCost(resolveIterationModel(requestModel, iteration.model), iterationUsage, timestamp);
-		cost.input += iterationUsage.cost.input;
-		cost.output += iterationUsage.cost.output;
-		cost.cacheRead += iterationUsage.cost.cacheRead;
-		cost.cacheWrite += iterationUsage.cost.cacheWrite;
-		cost.total += iterationUsage.cost.total;
-		applied = true;
-	}
-	if (!applied) return false;
-	usage.cost = cost;
-	return true;
-}
-/**
-* Detects the two shapes a signature-enforcing endpoint uses to reject a
-* replayed unsigned thinking block (sent as `signature: ""`):
-*
-* - Anthropic and Anthropic-fronting proxies: `400 Invalid `signature` in
-*   `thinking` block`.
-* - Bedrock-backed proxies: the empty string fails schema validation before
-*   signature checking, so it comes back as `ValidationException: The model
-*   returned the following errors: messages.N.content.M.thinking.signature:
-*   Field required`.
-*
-* Exported for the compat tests.
-*/
-const INVALID_THINKING_SIGNATURE_PATTERN = /invalid\s+`?signature`?\s+in\s+`?thinking`?(?:\s+block)?/i;
-const MISSING_THINKING_SIGNATURE_PATTERN = /thinking\.signature\b[^"\n]{0,32}\brequired\b/i;
-const THINKING_PREFIX_BINDING_PATTERN = /(?:bound to a different conversation|block_binding\.prefix_mismatch_behavior|prefix_mismatch_behavior)/i;
-/** Detects the preserved-thinking error caused by rewriting a signed block's conversation prefix. */
-function isThinkingPrefixBindingError(message) {
-	return INVALID_THINKING_SIGNATURE_PATTERN.test(message) && THINKING_PREFIX_BINDING_PATTERN.test(message);
-}
-function isInvalidThinkingSignatureError(message) {
-	return INVALID_THINKING_SIGNATURE_PATTERN.test(message) || MISSING_THINKING_SIGNATURE_PATTERN.test(message);
-}
-const INPUT_TRANSFORMATION_PATH_PATTERN = /^messages\.(\d+)\.content\.(\d+)$/;
-const PREFIX_BINDING_ERROR_PATH_PATTERN = /messages\.(\d+)\.content\.(\d+)/;
-function thinkingReplayKey(block) {
-	if (block.type === "thinking") return block.signature ? `thinking:${block.signature}` : void 0;
-	if (block.type === "redacted_thinking") return block.data ? `redacted:${block.data}` : void 0;
-}
-function rememberPrefixDroppedThinking(params, transformations, state) {
-	if (!state) return;
-	let firstMessageIndex;
-	let firstBlockIndex;
-	for (const transformation of transformations) {
-		if (transformation.reason !== "prefix_binding_mismatch" || typeof transformation.path !== "string") continue;
-		const match = INPUT_TRANSFORMATION_PATH_PATTERN.exec(transformation.path);
-		if (!match) continue;
-		const messageIndex = Number(match[1]);
-		const blockIndex = Number(match[2]);
-		if (firstMessageIndex === void 0 || messageIndex < firstMessageIndex || messageIndex === firstMessageIndex && blockIndex < (firstBlockIndex ?? Number.POSITIVE_INFINITY)) {
-			firstMessageIndex = messageIndex;
-			firstBlockIndex = blockIndex;
-		}
-	}
-	if (firstMessageIndex === void 0 || firstBlockIndex === void 0) return;
-	for (let messageIndex = firstMessageIndex; messageIndex < params.messages.length; messageIndex++) {
-		const message = params.messages[messageIndex];
-		if (!message || !Array.isArray(message.content)) continue;
-		const blockStart = messageIndex === firstMessageIndex ? firstBlockIndex : 0;
-		for (let blockIndex = blockStart; blockIndex < message.content.length; blockIndex++) {
-			const key = thinkingReplayKey(message.content[blockIndex]);
-			if (key) state.prefixDroppedThinkingBlocks.add(key);
-		}
-	}
-}
-function rememberPrefixBindingFailure(params, message, state) {
-	if (!state) return false;
-	const match = PREFIX_BINDING_ERROR_PATH_PATTERN.exec(message);
-	let path = match ? `messages.${match[1]}.content.${match[2]}` : void 0;
-	if (!path) for (let messageIndex = 0; messageIndex < params.messages.length && !path; messageIndex++) {
-		const candidate = params.messages[messageIndex];
-		if (!candidate || !Array.isArray(candidate.content)) continue;
-		const blockIndex = candidate.content.findIndex((block) => thinkingReplayKey(block) !== void 0);
-		if (blockIndex >= 0) path = `messages.${messageIndex}.content.${blockIndex}`;
-	}
-	if (!path) return false;
-	rememberPrefixDroppedThinking(params, [{
-		type: "thinking_dropped",
-		reason: "prefix_binding_mismatch",
-		path
-	}], state);
-	return true;
-}
-function applyReportedInputTransformations(output, params, state, value, seen, replace = false) {
-	if (value === void 0 || value === null) return;
-	if (replace) {
-		seen.clear();
-		output.inputTransformations = [];
-	}
-	const fresh = [];
-	for (const transformation of parseAnthropicInputTransformations(value)) {
-		const key = JSON.stringify(transformation);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		fresh.push(transformation);
-	}
-	if (fresh.length === 0) return;
-	output.inputTransformations = [...output.inputTransformations ?? [], ...fresh];
-	rememberPrefixDroppedThinking(params, fresh, state);
-	for (const transformation of fresh) {
-		if (transformation.reason !== "prefix_binding_mismatch") continue;
-		warn("anthropic: dropped thinking block after conversation prefix changed", {
-			model: output.model,
-			path: transformation.path
-		});
-	}
-}
-/**
-* Prepend a pointed remediation to a thinking-signature rejection 400 when the
-* model looks like an unmarked custom signing proxy
-* (opaque baseUrl, `spec.reasoning: true`, no explicit
-* `compat.replayUnsignedThinking` override). The default is native replay for
-* the 3p reasoning majority (#2005); this hint turns the misconfigured-proxy
-* case into a one-line fix instead of a silent retry loop (#4297).
-*/
-function maybeAddReplayUnsignedThinkingHint(model, message) {
-	if (!isInvalidThinkingSignatureError(message) || isThinkingPrefixBindingError(message)) return message;
-	if (model.compat.officialEndpoint) return message;
-	if (model.compatConfig?.replayUnsignedThinking !== void 0) return message;
-	return `${`Provider "${model.provider}" looks like an Anthropic-compatible signing proxy: it rejected a replayed unsigned thinking block. Set \`compat.replayUnsignedThinking: false\` under \`providers.${model.provider}\` in your models.yml and retry. See https://github.com/can1357/oh-my-pi/issues/4297.`}\n\n${message}`;
-}
-const streamAnthropicOnce = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const startTime = performance.now();
-		let firstTokenTime;
-		const output = {
-			role: "assistant",
-			content: [],
-			api: model.api,
-			provider: model.provider,
-			model: model.id,
-			usage: createEmptyUsage(),
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
-		let rawRequestDump;
-		let activeAbortTracker = createAbortSourceTracker(options?.signal);
-		const onSseEvent = options?.onSseEvent;
-		const rawSseObserver = onSseEvent ? (event) => onSseEvent(event, model) : void 0;
-		try {
-			const copilotDynamicHeaders = model.provider === "github-copilot" ? buildCopilotDynamicHeaders({
-				messages: context.messages,
-				hasImages: hasCopilotVisionInput(context.messages),
-				premiumMultiplier: model.premiumMultiplier,
-				headers: {
-					...model.headers,
-					...options?.headers
-				},
-				integrationId: resolveCopilotRequestIdentity(options?.headers),
-				initiatorOverride: options?.initiatorOverride
-			}) : void 0;
-			if (copilotDynamicHeaders?.premiumRequests !== void 0) output.usage.premiumRequests = copilotDynamicHeaders.premiumRequests;
-			const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
-			const baseUrl = resolveAnthropicBaseUrl(model, apiKey) ?? "https://api.anthropic.com";
-			const supportsEagerToolInputStreaming = resolveEagerToolInputStreamingSupport(model, baseUrl);
-			const providerSessionState = getAnthropicProviderSessionState(options?.providerSessionState, baseUrl, model.id);
-			let disableStrictTools = (providerSessionState?.strictToolsDisabled ?? false) || (model.compat?.disableStrictTools ?? false);
-			let dropFastMode = providerSessionState?.fastModeDisabled ?? false;
-			let forceDemoteUnsignedThinking = providerSessionState?.replayUnsignedThinkingDisabled ?? false;
-			let dropAllThinking = false;
-			let prefixBindingRetryAttempted = false;
-			let prefixMismatchBehavior = model.thinking?.prefixBinding && model.compat.supportsThinkingBindingControls ? options?.anthropicPrefixMismatchBehavior ?? "drop_block" : void 0;
-			const controlBetas = resolveAnthropicControlBetas(model, prefixMismatchBehavior);
-			const mergedCallerHeaders = mergeHeaders(model.headers, options?.headers);
-			const umansGatewayWebSearchHeader = getUmansWebSearchHeader(model, mergedCallerHeaders);
-			let fallbacks = options?.fallbacks;
-			if (!model.compat.supportsOutputEffort && fallbacks?.some((entry) => entry.output_config?.effort !== void 0)) fallbacks = fallbacks.map((entry) => {
-				const outputConfig = entry.output_config;
-				if (outputConfig?.effort === void 0) return entry;
-				return {
-					...entry,
-					output_config: outputConfig.task_budget === void 0 ? void 0 : { task_budget: outputConfig.task_budget }
-				};
-			});
-			const zeroOutputCacheRefresh = options?.anthropicCacheRefreshRequest === true;
-			let client;
-			let isOAuthToken;
-			if (options?.client) {
-				client = options.client;
-				isOAuthToken = false;
-			} else {
-				const extraBetas = normalizeExtraBetas(options?.betas);
-				if (model.provider === "anthropic" && options?.serviceTier === "priority" && !dropFastMode && !extraBetas.includes(fastModeBeta)) extraBetas.push(fastModeBeta);
-				if (options?.taskBudget && !extraBetas.includes(taskBudgetBeta)) extraBetas.push(taskBudgetBeta);
-				const sendsAdaptiveEffortPin = isAdaptiveOnlyThinking(model) && (options?.thinkingEnabled === false || model.compat.supportsForcedToolChoice && isForcedToolChoice(options?.toolChoice));
-				if (model.reasoning && model.compat.supportsOutputEffort && (options?.thinkingEnabled && options.effort !== "adaptive" || sendsAdaptiveEffortPin) && !extraBetas.includes(effortBeta)) extraBetas.push(effortBeta);
-				if (!isVertexRawPredictUrl(baseUrl)) {
-					for (const beta of controlBetas) if (!extraBetas.includes(beta)) extraBetas.push(beta);
-				}
-				if (model.reasoning && options?.thinkingEnabled && model.compat.supportsContextManagement !== false && !extraBetas.includes(contextManagementBeta)) extraBetas.push(contextManagementBeta);
-				if (!(options?.isOAuth ?? isAnthropicOAuthToken(apiKey)) && getCacheControl(model, options?.cacheRetention).cacheControl?.ttl === "1h" && !extraBetas.includes(extendedCacheTtlBeta)) extraBetas.push(extendedCacheTtlBeta);
-				if (fallbacks?.length) {
-					if (!extraBetas.includes(serverSideFallbackBeta)) extraBetas.push(serverSideFallbackBeta);
-					for (const entry of fallbacks) {
-						if (entry.speed === "fast" && !extraBetas.includes(fastModeBeta)) extraBetas.push(fastModeBeta);
-						if (entry.output_config?.effort && !extraBetas.includes(effortBeta)) extraBetas.push(effortBeta);
-						if (entry.output_config?.task_budget && !extraBetas.includes(taskBudgetBeta)) extraBetas.push(taskBudgetBeta);
-					}
-				}
-				const created = createClient(model, {
-					model,
-					apiKey,
-					extraBetas,
-					stream: !zeroOutputCacheRefresh,
-					interleavedThinking: options?.interleavedThinking ?? true,
-					headers: options?.headers,
-					dynamicHeaders: copilotDynamicHeaders?.headers,
-					isOAuth: options?.isOAuth,
-					hasTools: !!context.tools?.length,
-					thinkingEnabled: options?.thinkingEnabled,
-					thinkingDisplay: options?.thinkingDisplay,
-					fetch: options?.fetch,
-					maxRetryDelayMs: options?.maxRetryDelayMs,
-					sessionId: options?.sessionId ?? extractClaudeMetadataSessionId(options?.metadata?.user_id) ?? options?.promptCacheKey,
-					disableStrictTools
-				});
-				client = created.client;
-				isOAuthToken = created.isOAuthToken;
-			}
-			const preparedContext = await prepareAnthropicManyImageContext(context, model.input.includes("image"));
-			const prepareParams = async () => {
-				let nextParams = buildParams(model, preparedContext, isOAuthToken, options, {
-					disableStrictTools,
-					useUmansGatewayWebSearch: umansGatewayWebSearchHeader !== void 0,
-					forceDemoteUnsignedThinking,
-					supportsEagerToolInputStreaming,
-					prefixMismatchBehavior,
-					dropAllThinking,
-					droppedThinkingBlocks: providerSessionState?.prefixDroppedThinkingBlocks,
-					providerSessionState,
-					fallbacks
-				});
-				if (disableStrictTools) dropAnthropicStrictTools(nextParams);
-				if (dropFastMode) dropAnthropicFastMode(nextParams);
-				const replacementPayload = await options?.onPayload?.(nextParams, model);
-				if (replacementPayload !== void 0) nextParams = replacementPayload;
-				nextParams = toWellFormedDeep(nextParams);
-				rawRequestDump = {
-					provider: model.provider,
-					api: output.api,
-					model: model.id,
-					method: "POST",
-					url: `${baseUrl}/v1/messages${isOAuthToken ? "?beta=true" : ""}`,
-					body: nextParams
-				};
-				return nextParams;
-			};
-			let params = await prepareParams();
-			const seenInputTransformations = /* @__PURE__ */ new Set();
-			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs(model.compat.streamIdleTimeoutMs);
-			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
-			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
-			if (zeroOutputCacheRefresh) {
-				const refreshParams = {
-					...params,
-					max_tokens: 0,
-					stream: false
-				};
-				rawRequestDump = {
-					provider: model.provider,
-					api: output.api,
-					model: model.id,
-					method: "POST",
-					url: `${baseUrl}/v1/messages${isOAuthToken ? "?beta=true" : ""}`,
-					body: refreshParams
-				};
-				const { requestSignal } = activeAbortTracker;
-				const requestOptions = {
-					...createSdkStreamRequestOptions(requestSignal, requestTimeoutMs),
-					maxRetries: 0
-				};
-				const request = isOAuthToken && client.beta ? client.beta.messages.create(refreshParams, requestOptions) : client.messages.create(refreshParams, requestOptions);
-				if (!hasAnthropicRawResponseRequest(request)) throw new AnthropicStreamEnvelopeError("Anthropic cache refresh request did not expose a raw response");
-				const response = await request.asResponse();
-				await notifyProviderResponse(options, response, model, response.headers.get("request-id"));
-				const body = await response.json();
-				if (!isRecord(body)) throw new AnthropicStreamEnvelopeError("Anthropic cache refresh returned a malformed response");
-				const wireUsage = parseAnthropicWireUsage(body.usage);
-				if (!wireUsage) throw new AnthropicStreamEnvelopeError("Anthropic cache refresh response omitted usage");
-				if (typeof body.id === "string") output.responseId = body.id;
-				applyReportedInputTransformations(output, params, providerSessionState, body.input_transformations, seenInputTransformations);
-				output.usage.input = wireUsage.input_tokens ?? 0;
-				output.usage.output = wireUsage.output_tokens ?? 0;
-				output.usage.cacheRead = wireUsage.cache_read_input_tokens ?? 0;
-				output.usage.cacheWrite = wireUsage.cache_creation_input_tokens ?? 0;
-				applyAnthropicUsageExtras(output.usage, wireUsage);
-				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-				calculateCost(model, output.usage, output.timestamp);
-				output.duration = performance.now() - startTime;
-				stream.push({
-					type: "start",
-					partial: output
-				});
-				stream.push({
-					type: "done",
-					reason: "stop",
-					message: output
-				});
-				stream.end();
-				return;
-			}
-			const serverSideFallback = !!fallbacks?.length;
-			const blocks = output.content;
-			const finalizeStreamBlock = (block, contentIndex) => {
-				if (block.type === "text") stream.push({
-					type: "text_end",
-					contentIndex,
-					content: block.text,
-					partial: output
-				});
-				else if (block.type === "thinking") {
-					const unwrappedThinking = unwrapAnthropicThinkingEnvelope(block.thinking);
-					if (unwrappedThinking !== void 0) {
-						block.thinking = unwrappedThinking;
-						block.thinkingSignature = void 0;
-					}
-					stream.push({
-						type: "thinking_end",
-						contentIndex,
-						content: block.thinking,
-						partial: output
-					});
-				} else if (block.type === "anthropicServerTool" && block.block.type === "server_tool_use") {
-					const partialJson = block[kStreamingPartialJson];
-					if (partialJson) try {
-						const input = parseJsonWithRepair(partialJson);
-						if (isRecord(input)) block.block.input = input;
-						else reportAnthropicEnvelopeAnomaly("server_tool_use input is not a JSON object");
-					} catch (parseError) {
-						reportAnthropicEnvelopeAnomaly(`server_tool_use ${block.block.id} input is not valid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-					}
-					clearStreamingPartialJson(block);
-				} else if (block.type === "toolCall") {
-					const finalJson = block[kStreamingPartialJson].length > 0 ? block[kStreamingPartialJson] : JSON.stringify(block.arguments ?? {});
-					try {
-						block.arguments = parseJsonWithRepair(finalJson);
-					} catch (parseError) {
-						reportAnthropicEnvelopeAnomaly(`tool_use ${block.id} arguments are not valid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-						if (Object.keys(block.arguments ?? {}).length === 0) {
-							const maxLen = 512;
-							const truncatedJson = finalJson.length <= maxLen ? finalJson : `${finalJson.slice(0, maxLen)}… [truncated ${finalJson.length - maxLen} chars]`;
-							block.arguments = {
-								__parseError: parseError instanceof Error ? parseError.message : String(parseError),
-								__rawJson: truncatedJson
-							};
-						}
-					}
-					clearStreamingPartialJson(block);
-					stream.push({
-						type: "toolcall_end",
-						contentIndex,
-						toolCall: block,
-						partial: output
-					});
-				}
-			};
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			let providerRetryAttempt = 0;
-			const firstEventTimeoutAbortError = new StreamTimeoutError("Anthropic stream timed out while waiting for the first event");
-			const idleTimeoutAbortError = new StreamTimeoutError("Anthropic stream stalled while waiting for the next event");
-			while (true) {
-				activeAbortTracker = createAbortSourceTracker(options?.signal);
-				const { requestSignal } = activeAbortTracker;
-				let injectedClientBetaHeaders;
-				if (options?.client !== void 0 && !isVertexRawPredictUrl(baseUrl)) {
-					for (const beta of controlBetas) injectedClientBetaHeaders = mergeAnthropicBetaHeader(injectedClientBetaHeaders ?? mergedCallerHeaders, beta);
-					if (params.output_config?.effort !== void 0) injectedClientBetaHeaders = mergeAnthropicBetaHeader(injectedClientBetaHeaders ?? mergedCallerHeaders, effortBeta);
-				}
-				const perRequestHeaders = umansGatewayWebSearchHeader || injectedClientBetaHeaders ? {
-					...umansGatewayWebSearchHeader,
-					...injectedClientBetaHeaders
-				} : void 0;
-				const requestOptions = {
-					...createSdkStreamRequestOptions(requestSignal, requestTimeoutMs),
-					maxRetries: 0,
-					...perRequestHeaders ? { headers: perRequestHeaders } : {}
-				};
-				const anthropicRequest = isOAuthToken && client.beta ? client.beta.messages.create({
-					...params,
-					stream: true
-				}, requestOptions) : client.messages.create({
-					...params,
-					stream: true
-				}, requestOptions);
-				let streamedReplayUnsafeContent = false;
-				try {
-					let requestTimeout;
-					if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => activeAbortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
-					let anthropicStream;
-					let response;
-					let requestId;
-					let recordsRawSseEvents;
-					try {
-						({events: anthropicStream, response, requestId, recordsRawSseEvents} = await getAnthropicStreamResponse(anthropicRequest, requestSignal, rawSseObserver));
-					} catch (error) {
-						if (error instanceof AnthropicConnectionTimeoutError && !activeAbortTracker.wasCallerAbort()) throw firstEventTimeoutAbortError;
-						throw error;
-					} finally {
-						if (requestTimeout !== void 0) clearTimeout(requestTimeout);
-					}
-					await notifyProviderResponse(options, response, model, requestId);
-					let sawEvent = false;
-					let sawMessageStart = false;
-					let sawTerminalEnvelope = false;
-					let sawMessageStop = false;
-					let sawSplicedEnvelope = false;
-					const closedBlockIndexes = /* @__PURE__ */ new Set();
-					const openBlocks = /* @__PURE__ */ new Map();
-					let sawNonPingEvent = false;
-					let lastNonPingProgressAtMs = 0;
-					const pingProgressCapMs = idleTimeoutMs !== void 0 && idleTimeoutMs > 0 ? idleTimeoutMs * PING_PROGRESS_MAX_IDLE_MULTIPLIER : void 0;
-					const timedAnthropicStream = iterateWithIdleTimeout(anthropicStream, {
-						idleTimeoutMs,
-						firstItemTimeoutMs: firstEventTimeoutMs,
-						errorMessage: idleTimeoutAbortError.message,
-						firstItemErrorMessage: firstEventTimeoutAbortError.message,
-						onIdle: () => activeAbortTracker.abortLocally(idleTimeoutAbortError),
-						onFirstItemTimeout: () => activeAbortTracker.abortLocally(firstEventTimeoutAbortError),
-						abortSignal: options?.signal,
-						isProgressItem: (item) => {
-							if (item.type === "ping") {
-								if (!sawNonPingEvent) return false;
-								if (pingProgressCapMs === void 0) return true;
-								return Date.now() - lastNonPingProgressAtMs < pingProgressCapMs;
-							}
-							sawNonPingEvent = true;
-							lastNonPingProgressAtMs = Date.now();
-							return true;
-						}
-					});
-					const observedAnthropicStream = rawSseObserver && !recordsRawSseEvents ? observeDecodedAnthropicSdkEvents(timedAnthropicStream, rawSseObserver) : timedAnthropicStream;
-					for await (const event of observedAnthropicStream) {
-						sawEvent = true;
-						if (event.type === "message_start") {
-							if (sawMessageStart) {
-								reportAnthropicEnvelopeAnomaly("duplicate message_start event");
-								sawSplicedEnvelope = true;
-								continue;
-							}
-							sawMessageStart = true;
-							const startMessage = event.message;
-							if (startMessage?.id) output.responseId = startMessage.id;
-							applyReportedInputTransformations(output, params, providerSessionState, startMessage?.input_transformations, seenInputTransformations);
-							const startUsage = startMessage?.usage;
-							if (startUsage) {
-								applyAnthropicUsageExtras(output.usage, startUsage);
-								output.usage.input = startUsage.input_tokens || 0;
-								output.usage.output = startUsage.output_tokens || 0;
-								output.usage.cacheRead = startUsage.cache_read_input_tokens || 0;
-								output.usage.cacheWrite = startUsage.cache_creation_input_tokens || 0;
-								output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-								if (serverSideFallback) {
-									const served = fallbackServedModelFromUsage(startUsage);
-									if (served) output.model = served;
-									if (!calculateFallbackTurnCost(model, output.usage, startUsage, output.timestamp)) calculateCost(model, output.usage, output.timestamp);
-								} else calculateCost(model, output.usage, output.timestamp);
-							} else reportAnthropicEnvelopeAnomaly("message_start missing usage");
-							continue;
-						}
-						if (!sawMessageStart) {
-							if (shouldIgnoreAnthropicPreambleEvent(event.type)) continue;
-							throw new AnthropicStreamEnvelopeError(`received ${event.type} before message_start`);
-						}
-						if (event.type === "content_block_start") {
-							if (sawTerminalEnvelope) {
-								reportAnthropicEnvelopeAnomaly(`received ${event.type} after terminal stop signal`);
-								continue;
-							}
-							if (openBlocks.has(event.index)) {
-								reportAnthropicEnvelopeAnomaly(`duplicate content_block_start index ${event.index}`);
-								continue;
-							}
-							if (sawSplicedEnvelope && closedBlockIndexes.has(event.index)) {
-								reportAnthropicEnvelopeAnomaly(`replayed content_block_start index ${event.index} after duplicate message_start`);
-								openBlocks.set(event.index, {
-									contentIndex: -1,
-									kind: "ignored"
-								});
-								continue;
-							}
-							if (!event.content_block?.type) {
-								reportAnthropicEnvelopeAnomaly("content_block_start missing content_block payload");
-								continue;
-							}
-							if (!firstTokenTime) firstTokenTime = performance.now();
-							if (event.content_block.type === "fallback") {
-								const fallback = parseAnthropicFallbackWireBlock(event.content_block);
-								if (!serverSideFallback || !fallback) {
-									if (!fallback) reportAnthropicEnvelopeAnomaly("fallback content_block missing model refs");
-									openBlocks.set(event.index, {
-										contentIndex: -1,
-										kind: "ignored"
-									});
-									continue;
-								}
-								const block = {
-									...fallback,
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								openBlocks.set(event.index, {
-									contentIndex: output.content.length - 1,
-									kind: "fallback"
-								});
-								output.model = fallback.to.model;
-								continue;
-							}
-							if (event.content_block.type === "text") {
-								streamedReplayUnsafeContent = true;
-								const block = {
-									type: "text",
-									text: "",
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								const contentIndex = output.content.length - 1;
-								openBlocks.set(event.index, {
-									contentIndex,
-									kind: "text"
-								});
-								stream.push({
-									type: "text_start",
-									contentIndex,
-									partial: output
-								});
-							} else if (event.content_block.type === "thinking") {
-								streamedReplayUnsafeContent = true;
-								const block = {
-									type: "thinking",
-									thinking: event.content_block.thinking ?? "",
-									thinkingSignature: "",
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								const contentIndex = output.content.length - 1;
-								openBlocks.set(event.index, {
-									contentIndex,
-									kind: "thinking"
-								});
-								stream.push({
-									type: "thinking_start",
-									contentIndex,
-									partial: output
-								});
-								if (block.thinking) stream.push({
-									type: "thinking_delta",
-									contentIndex,
-									delta: block.thinking,
-									partial: output
-								});
-							} else if (event.content_block.type === "redacted_thinking") {
-								streamedReplayUnsafeContent = true;
-								const block = {
-									type: "redactedThinking",
-									data: event.content_block.data,
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								openBlocks.set(event.index, {
-									contentIndex: output.content.length - 1,
-									kind: "redactedThinking"
-								});
-							} else if (isAnthropicServerToolHistoryBlock(event.content_block) && (umansGatewayWebSearchHeader === void 0 || (event.content_block.type === "server_tool_use" ? event.content_block.name !== "web_search" : event.content_block.type !== "web_search_tool_result"))) {
-								streamedReplayUnsafeContent = true;
-								const block = {
-									type: "anthropicServerTool",
-									block: { ...event.content_block },
-									[kStreamingPartialJson]: "",
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								openBlocks.set(event.index, {
-									contentIndex: output.content.length - 1,
-									kind: "anthropicServerTool"
-								});
-							} else if (event.content_block.type === "tool_use") {
-								streamedReplayUnsafeContent = true;
-								const block = {
-									type: "toolCall",
-									id: event.content_block.id,
-									name: decodeAnthropicToolName(event.content_block.name, isOAuthToken, model.compat.escapeBuiltinToolNames),
-									arguments: event.content_block.input ?? {},
-									[kStreamingPartialJson]: "",
-									[kStreamingBlockIndex]: event.index
-								};
-								output.content.push(block);
-								const contentIndex = output.content.length - 1;
-								openBlocks.set(event.index, {
-									contentIndex,
-									kind: "toolCall"
-								});
-								stream.push({
-									type: "toolcall_start",
-									contentIndex,
-									partial: output
-								});
-							} else openBlocks.set(event.index, {
-								contentIndex: -1,
-								kind: "ignored"
-							});
-						} else if (event.type === "content_block_delta") {
-							if (sawTerminalEnvelope) {
-								reportAnthropicEnvelopeAnomaly(`received ${event.type} after terminal stop signal`);
-								continue;
-							}
-							const openBlock = openBlocks.get(event.index);
-							if (!openBlock) {
-								reportAnthropicEnvelopeAnomaly(`received content_block_delta for unopened index ${event.index}`);
-								continue;
-							}
-							if (openBlock.kind === "ignored") continue;
-							if (!event.delta?.type) {
-								reportAnthropicEnvelopeAnomaly("content_block_delta missing delta payload");
-								continue;
-							}
-							const block = blocks[openBlock.contentIndex];
-							if (event.delta.type === "text_delta") {
-								if (openBlock.kind !== "text" || block?.type !== "text") {
-									reportAnthropicEnvelopeAnomaly(`received text_delta for ${openBlock.kind} block`);
-									continue;
-								}
-								streamedReplayUnsafeContent = true;
-								block.text += event.delta.text;
-								stream.push({
-									type: "text_delta",
-									contentIndex: openBlock.contentIndex,
-									delta: event.delta.text,
-									partial: output
-								});
-							} else if (event.delta.type === "thinking_delta") {
-								if (openBlock.kind !== "thinking" || block?.type !== "thinking") {
-									reportAnthropicEnvelopeAnomaly(`received thinking_delta for ${openBlock.kind} block`);
-									continue;
-								}
-								streamedReplayUnsafeContent = true;
-								block.thinking += event.delta.thinking;
-								stream.push({
-									type: "thinking_delta",
-									contentIndex: openBlock.contentIndex,
-									delta: event.delta.thinking,
-									partial: output
-								});
-							} else if (event.delta.type === "input_json_delta") {
-								if (openBlock.kind === "anthropicServerTool" && block?.type === "anthropicServerTool" && block.block.type === "server_tool_use") {
-									block[kStreamingPartialJson] = (block[kStreamingPartialJson] ?? "") + event.delta.partial_json;
-									continue;
-								}
-								if (openBlock.kind !== "toolCall" || block?.type !== "toolCall") {
-									reportAnthropicEnvelopeAnomaly(`received input_json_delta for ${openBlock.kind} block`);
-									continue;
-								}
-								streamedReplayUnsafeContent = true;
-								block[kStreamingPartialJson] += event.delta.partial_json;
-								const throttled = parseStreamingJsonThrottled(block[kStreamingPartialJson], block[kStreamingLastParseLen] ?? 0);
-								if (throttled) {
-									block.arguments = throttled.value;
-									block[kStreamingLastParseLen] = throttled.parsedLen;
-								}
-								stream.push({
-									type: "toolcall_delta",
-									contentIndex: openBlock.contentIndex,
-									delta: event.delta.partial_json,
-									partial: output
-								});
-							} else if (event.delta.type === "signature_delta") {
-								if (openBlock.kind !== "thinking" || block?.type !== "thinking") {
-									reportAnthropicEnvelopeAnomaly(`received signature_delta for ${openBlock.kind} block`);
-									continue;
-								}
-								streamedReplayUnsafeContent = true;
-								block.thinkingSignature = block.thinkingSignature || "";
-								block.thinkingSignature += event.delta.signature;
-							}
-						} else if (event.type === "content_block_stop") {
-							if (sawTerminalEnvelope) {
-								reportAnthropicEnvelopeAnomaly(`received ${event.type} after terminal stop signal`);
-								continue;
-							}
-							const openBlock = openBlocks.get(event.index);
-							if (!openBlock) {
-								reportAnthropicEnvelopeAnomaly(`received content_block_stop for unopened index ${event.index}`);
-								continue;
-							}
-							if (openBlock.kind === "ignored") {
-								openBlocks.delete(event.index);
-								continue;
-							}
-							const block = blocks[openBlock.contentIndex];
-							if (!block || block.type !== openBlock.kind) {
-								reportAnthropicEnvelopeAnomaly(`content_block_stop kind mismatch for index ${event.index}`);
-								openBlocks.delete(event.index);
-								continue;
-							}
-							openBlocks.delete(event.index);
-							closedBlockIndexes.add(event.index);
-							finalizeStreamBlock(block, openBlock.contentIndex);
-						} else if (event.type === "message_delta") {
-							if (sawTerminalEnvelope) {
-								reportAnthropicEnvelopeAnomaly("received message_delta after terminal stop signal");
-								continue;
-							}
-							const delta = event.delta;
-							applyReportedInputTransformations(output, params, providerSessionState, event.input_transformations, seenInputTransformations, true);
-							const rawStopReason = delta?.stop_reason;
-							if (rawStopReason) {
-								output.stopReason = mapStopReason(rawStopReason);
-								sawTerminalEnvelope = true;
-							}
-							if (output.stopReason === "error") {
-								const stopDetails = delta?.stop_details;
-								output.stopDetails = stopDetails ?? (rawStopReason ? { type: rawStopReason } : null);
-								if (stopDetails?.type === "refusal") {
-									const explanation = stopDetails.explanation?.trim();
-									const category = stopDetails.category;
-									const label = category ? `Refusal (${category})` : "Refusal";
-									output.errorMessage = explanation ? `${label}: ${explanation}` : label;
-								} else if (!output.errorMessage) output.errorMessage = rawStopReason === "refusal" ? "Refusal (no details provided)" : rawStopReason === "sensitive" ? "Content flagged by safety filters" : `Anthropic stream ended with stop_reason: ${rawStopReason ?? "unknown"}`;
-							}
-							const deltaUsage = event.usage;
-							if (deltaUsage) {
-								if (deltaUsage.input_tokens != null) output.usage.input = deltaUsage.input_tokens;
-								if (deltaUsage.output_tokens != null) output.usage.output = deltaUsage.output_tokens;
-								if (deltaUsage.cache_read_input_tokens != null) output.usage.cacheRead = deltaUsage.cache_read_input_tokens;
-								if (deltaUsage.cache_creation_input_tokens != null) output.usage.cacheWrite = deltaUsage.cache_creation_input_tokens;
-								applyAnthropicUsageExtras(output.usage, deltaUsage);
-								output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-								if (serverSideFallback) {
-									const served = fallbackServedModelFromUsage(deltaUsage);
-									if (served) output.model = served;
-									if (!calculateFallbackTurnCost(model, output.usage, deltaUsage, output.timestamp)) calculateCost(model, output.usage, output.timestamp);
-								} else calculateCost(model, output.usage, output.timestamp);
-							}
-						} else if (event.type === "message_stop") {
-							sawTerminalEnvelope = true;
-							sawMessageStop = true;
-							break;
-						}
-					}
-					const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
-					if (firstEventTimeoutError) throw firstEventTimeoutError;
-					if (activeAbortTracker.wasCallerAbort()) throw new AbortError();
-					if (!sawEvent || !sawMessageStart) throw new AnthropicStreamEnvelopeError("stream ended before message_start");
-					if (!sawTerminalEnvelope) throw new AnthropicStreamEnvelopeError("stream ended before message_stop");
-					if (!sawMessageStop) reportAnthropicEnvelopeAnomaly("stream ended before message_stop");
-					if (openBlocks.size > 0) {
-						for (const [openIndex, openBlock] of openBlocks) {
-							reportAnthropicEnvelopeAnomaly(`stream ended with an unterminated ${openBlock.kind} block at index ${openIndex}`);
-							if (openBlock.kind === "ignored" || openBlock.contentIndex < 0) continue;
-							const danglingBlock = blocks[openBlock.contentIndex];
-							if (danglingBlock) finalizeStreamBlock(danglingBlock, openBlock.contentIndex);
-						}
-						openBlocks.clear();
-					}
-					if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
-						provider: model.provider,
-						kind: "output"
-					});
-					break;
-				} catch (streamError) {
-					const streamFailure = activeAbortTracker.getLocalAbortReason() ?? streamError;
-					if (!disableStrictTools && firstTokenTime === void 0 && hasStrictAnthropicTools(params) && isGrammarError(streamFailure)) {
-						warn("anthropic: strict tools rejected, retrying without strict tools", {
-							model: model.id,
-							error: await finalizeErrorMessage(streamFailure, rawRequestDump)
-						});
-						if (providerSessionState) providerSessionState.strictToolsDisabled = true;
-						disableStrictTools = true;
-						params = await prepareParams();
-						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.model = model.id;
-						output.responseId = void 0;
-						output.errorMessage = void 0;
-						output.providerPayload = void 0;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = void 0;
-						continue;
-					}
-					const streamFailureMessage = streamFailure instanceof Error ? streamFailure.message : String(streamFailure);
-					if (!prefixBindingRetryAttempted && options?.anthropicPrefixMismatchBehavior !== "error" && firstTokenTime === void 0 && !streamedReplayUnsafeContent && isThinkingPrefixBindingError(streamFailureMessage)) {
-						warn("anthropic: thinking prefix changed, stripping bound thinking and retrying", {
-							provider: model.provider,
-							model: model.id,
-							baseUrl
-						});
-						prefixBindingRetryAttempted = true;
-						prefixMismatchBehavior = void 0;
-						dropAllThinking = !rememberPrefixBindingFailure(params, streamFailureMessage, providerSessionState);
-						params = await prepareParams();
-						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.model = model.id;
-						output.responseId = void 0;
-						output.errorMessage = void 0;
-						output.inputTransformations = void 0;
-						output.providerPayload = void 0;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = void 0;
-						continue;
-					}
-					if (!forceDemoteUnsignedThinking && firstTokenTime === void 0 && !streamedReplayUnsafeContent && !isThinkingPrefixBindingError(streamFailureMessage) && isInvalidThinkingSignatureError(streamFailureMessage)) {
-						warn("anthropic: signing proxy detected (thinking signature rejected), demoting unsigned thinking and retrying", {
-							provider: model.provider,
-							model: model.id,
-							baseUrl,
-							error: streamFailureMessage
-						});
-						if (providerSessionState) providerSessionState.replayUnsignedThinkingDisabled = true;
-						forceDemoteUnsignedThinking = true;
-						params = await prepareParams();
-						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.model = model.id;
-						output.responseId = void 0;
-						output.errorMessage = void 0;
-						output.providerPayload = void 0;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = void 0;
-						continue;
-					}
-					if (!dropFastMode && model.provider === "anthropic" && options?.serviceTier === "priority" && firstTokenTime === void 0 && isFastModeUnsupported(streamFailure)) {
-						debug("anthropic: fast mode unsupported, retrying without speed", {
-							model: model.id,
-							error: streamFailure instanceof Error ? streamFailure.message : String(streamFailure)
-						});
-						if (providerSessionState) providerSessionState.fastModeDisabled = true;
-						dropFastMode = true;
-						params = await prepareParams();
-						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.model = model.id;
-						output.responseId = void 0;
-						output.errorMessage = void 0;
-						output.providerPayload = void 0;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = void 0;
-						continue;
-					}
-					const isTransientEnvelopeFailure = isTransientStreamParseError(streamFailure) || isStreamEnvelopeError(streamFailure);
-					const isLocalIdleTimeout = streamFailure === idleTimeoutAbortError || streamFailure instanceof Error && streamFailure.message === idleTimeoutAbortError.message;
-					const canRetryTransientEnvelopeFailure = isTransientEnvelopeFailure && !streamedReplayUnsafeContent;
-					const canRetryProviderFailure = !isLocalIdleTimeout && firstTokenTime === void 0 && !streamedReplayUnsafeContent && isProviderRetryableError(streamFailure);
-					if (activeAbortTracker.wasCallerAbort() || providerRetryAttempt >= PROVIDER_MAX_RETRIES || !canRetryTransientEnvelopeFailure && !canRetryProviderFailure) throw streamFailure;
-					providerRetryAttempt++;
-					const backoffDelayMs = calculateAnthropicRetryDelayMs(providerRetryAttempt - 1);
-					const headerDelayMs = getRetryAfterMsFromHeaders(getHeadersFromError(streamFailure));
-					const maxRetryDelayMs = options?.maxRetryDelayMs ?? 6e4;
-					if (headerDelayMs !== void 0 && maxRetryDelayMs > 0 && headerDelayMs > maxRetryDelayMs) throw streamFailure;
-					const delayMs = headerDelayMs !== void 0 ? Math.max(headerDelayMs, backoffDelayMs) : backoffDelayMs;
-					if (options?.providerRetryWait) await options.providerRetryWait(delayMs, options.signal);
-					else await scheduler.wait(delayMs, { signal: options?.signal });
-					output.content.length = 0;
-					output.model = model.id;
-					output.responseId = void 0;
-					output.errorMessage = void 0;
-					output.stopDetails = void 0;
-					output.providerPayload = void 0;
-					output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-					output.stopReason = "stop";
-					firstTokenTime = void 0;
-				}
-			}
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			if (dropFastMode && model.provider === "anthropic" && options?.serviceTier === "priority") output.disabledFeatures = [...output.disabledFeatures ?? [], "priority"];
-			if (forceDemoteUnsignedThinking && model.compat.replayUnsignedThinking) output.disabledFeatures = [...output.disabledFeatures ?? [], "unsigned-thinking-replay"];
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) if (block.type === "toolCall") clearStreamingPartialJson(block);
-			const result = await finalize(error, {
-				api: model.api,
-				provider: model.provider,
-				abortTracker: activeAbortTracker,
-				rawRequestDump
-			});
-			output.stopReason = result.stopReason;
-			output.errorStatus = result.status;
-			output.errorId = result.id;
-			output.errorMessage = maybeAddReplayUnsignedThinkingHint(model, result.message);
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-/**
-* Public entry: retry benign empty completions before they reach the agent
-* loop. The inner attempt owns Anthropic provider-failure retries.
-*/
-const streamAnthropic = (model, context, options) => withReplaySafeStreamRetry(model, context, options, streamAnthropicOnce, { retryEmptyCompletion: true });
-function buildAnthropicSystemBlocks(systemPrompt, options = {}) {
-	const { includeClaudeCodeInstruction = false, extraInstructions = [], firstUserMessageText, cacheControl } = options;
-	const sanitizedPrompts = normalizeSystemPrompts(systemPrompt);
-	const trimmedInstructions = extraInstructions.map((instruction) => instruction.trim()).filter(Boolean);
-	const hasBillingHeader = sanitizedPrompts.some((prompt) => prompt.startsWith(CLAUDE_BILLING_HEADER_PREFIX));
-	if (includeClaudeCodeInstruction && !hasBillingHeader) {
-		const blocks = [{
-			type: "text",
-			text: createClaudeBillingHeader(firstUserMessageText ?? "")
-		}, {
-			type: "text",
-			text: claudeCodeSystemInstruction,
-			cache_control: cacheControl ? cloneAnthropicCacheControl(cacheControl) : { type: "ephemeral" }
-		}];
-		for (const instruction of trimmedInstructions) blocks.push({
-			type: "text",
-			text: instruction
-		});
-		for (const prompt of sanitizedPrompts) blocks.push({
-			type: "text",
-			text: prompt
-		});
-		return blocks;
-	}
-	const blocks = [];
-	for (const instruction of trimmedInstructions) blocks.push({
-		type: "text",
-		text: instruction
-	});
-	for (const prompt of sanitizedPrompts) blocks.push({
-		type: "text",
-		text: prompt
-	});
-	return blocks.length > 0 ? blocks : void 0;
-}
-function normalizeExtraBetas(betas) {
-	if (!betas) return [];
-	return (Array.isArray(betas) ? betas : betas.split(",")).map((beta) => beta.trim()).filter((beta) => beta.length > 0);
-}
-function buildAnthropicClientOptions(args) {
-	const { model, apiKey, extraBetas = [], stream = true, interleavedThinking = true, headers, dynamicHeaders, hasTools = false, thinkingEnabled = false, isOAuth, maxRetryDelayMs, sessionId, disableStrictTools: disableStrictToolsOverride } = args;
-	const compat = model.compat;
-	const disableStrictTools = disableStrictToolsOverride ?? compat.disableStrictTools;
-	const baseUrl = resolveAnthropicBaseUrl(model, apiKey);
-	const needsInterleavedBeta = interleavedThinking && (!model.thinking?.supportsDisplay || !isOfficialAnthropicApiUrl(baseUrl) && (isAnthropicSigningProxyUrl(baseUrl) || compat.signingEndpoint && !compat.officialEndpoint) && !isVertexRawPredictUrl(baseUrl ?? "") && !hostMatchesUrl(baseUrl, "githubCopilot"));
-	const oauthToken = isOAuth ?? isAnthropicOAuthToken(apiKey);
-	const supportsEagerToolInputStreaming = resolveEagerToolInputStreamingSupport(model, baseUrl);
-	const needsFineGrainedToolStreamingBeta = hasTools && isOfficialAnthropicApiUrl(baseUrl) && !supportsEagerToolInputStreaming;
-	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model, baseUrl);
-	const fetchOptions = {
-		...buildClaudeCodeTlsFetchOptions(model, baseUrl),
-		timeout: false
-	};
-	const baseFetch = args.fetch ?? fetch;
-	const cchFetch = oauthToken ? wrapFetchForCch(baseFetch) : baseFetch;
-	if (model.provider === "github-copilot") {
-		const copilotApiKey = parseGitHubCopilotApiKey(apiKey).accessToken;
-		const betaFeatures = [...extraBetas];
-		const defaultHeaders = mergeHeaders({
-			Accept: stream ? "text/event-stream" : "application/json",
-			"Content-Type": "application/json",
-			"anthropic-version": "2023-06-01",
-			"Anthropic-Dangerous-Direct-Browser-Access": "true",
-			Authorization: `Bearer ${copilotApiKey}`,
-			...betaFeatures.length > 0 ? { "anthropic-beta": buildBetaHeader([], betaFeatures) } : {}
-		}, model.headers, dynamicHeaders, headers);
-		applyInferenceHeaders(defaultHeaders, {
-			provider: model.provider,
-			protocol: "anthropic",
-			sessionId
-		});
-		return {
-			isOAuthToken: false,
-			apiKey: null,
-			authToken: copilotApiKey,
-			baseURL: baseUrl,
-			maxRetries: 5,
-			maxRetryDelayMs,
-			defaultHeaders,
-			fetch: wrapFetchForCopilotFallback(cchFetch, true, resolveCopilotRequestIdentity(headers)),
-			fetchOptions
-		};
-	}
-	const betaFeatures = [...extraBetas];
-	if (needsFineGrainedToolStreamingBeta) betaFeatures.push(fineGrainedToolStreamingBeta);
-	if (needsInterleavedBeta) betaFeatures.push(interleavedThinkingBeta);
-	const defaultHeaders = buildAnthropicHeaders({
-		apiKey,
-		baseUrl,
-		isOAuth: oauthToken,
-		extraBetas: betaFeatures,
-		stream,
-		modelHeaders: mergeHeaders(model.headers, foundryCustomHeaders, getUmansWebSearchHeader(model, mergeHeaders(model.headers, headers)), headers, dynamicHeaders),
-		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
-		allowAnthropicHeaderOverrides: model.compat.allowAnthropicHeaderOverrides,
-		claudeCodeSessionId: sessionId,
-		claudeCodeBetas: oauthToken ? buildClaudeCodeBetas({
-			agentRequest: hasTools || thinkingEnabled,
-			thinkingRequest: thinkingEnabled,
-			disableStrictTools,
-			supportsContextManagement: model.compat.supportsContextManagement
-		}) : []
-	});
-	applyInferenceHeaders(defaultHeaders, {
-		provider: model.provider,
-		protocol: "anthropic",
-		sessionId
-	});
-	if (model.provider === "cloudflare-ai-gateway") return {
-		isOAuthToken: false,
-		apiKey: null,
-		authToken: null,
-		baseURL: baseUrl,
-		maxRetries: 5,
-		maxRetryDelayMs,
-		defaultHeaders,
-		fetch: cchFetch,
-		fetchOptions
-	};
-	if (model.provider === "opencode-go" || model.provider === "opencode-zen" || model.provider === "umans") {
-		delete defaultHeaders.Authorization;
-		return {
-			isOAuthToken: false,
-			apiKey,
-			authToken: null,
-			baseURL: baseUrl,
-			maxRetries: 5,
-			maxRetryDelayMs,
-			defaultHeaders,
-			fetch: cchFetch,
-			fetchOptions
-		};
-	}
-	const authorizationHeader = getHeaderCaseInsensitive(defaultHeaders, "Authorization");
-	const shouldSuppressClientApiKey = !oauthToken && !model.compat.officialEndpoint && typeof authorizationHeader === "string";
-	return {
-		isOAuthToken: oauthToken,
-		apiKey: oauthToken || shouldSuppressClientApiKey ? null : apiKey,
-		authToken: oauthToken ? apiKey : void 0,
-		baseURL: baseUrl,
-		maxRetries: 5,
-		maxRetryDelayMs,
-		defaultHeaders,
-		fetch: cchFetch,
-		fetchOptions
-	};
-}
-function createClient(model, args) {
-	const { isOAuthToken: oauthToken, ...clientOptions } = buildAnthropicClientOptions({
-		...args,
-		model
-	});
-	return {
-		client: new AnthropicMessagesClient(clientOptions),
-		isOAuthToken: oauthToken
-	};
-}
-function disableThinkingIfToolChoiceForced(params, model) {
-	const toolChoice = params.tool_choice;
-	if (!toolChoice) return;
-	if (toolChoice.type !== "any" && toolChoice.type !== "tool") return;
-	delete params.thinking;
-	delete params.context_management;
-	if (isAdaptiveOnlyThinking(model) && model.compat.supportsOutputEffort) {
-		const outputConfig = params.output_config ?? {};
-		outputConfig.effort = "low";
-		params.output_config = outputConfig;
-		return;
-	}
-	const outputConfig = params.output_config;
-	if (!outputConfig) return;
-	delete outputConfig.effort;
-	if (Object.keys(outputConfig).length === 0) delete params.output_config;
-}
-function ensureMaxTokensForThinking(params, maxAllowedTokens) {
-	const thinking = params.thinking;
-	if (thinking?.type !== "enabled") return;
-	const budgetTokens = thinking.budget_tokens ?? 0;
-	if (budgetTokens <= 0) return;
-	const currentMaxTokens = Math.min(params.max_tokens ?? maxAllowedTokens, maxAllowedTokens);
-	const raisedMaxTokens = Math.min(Math.max(currentMaxTokens, budgetTokens + OUTPUT_FALLBACK_BUFFER), maxAllowedTokens);
-	params.max_tokens = raisedMaxTokens;
-	if (budgetTokens + 4e3 <= raisedMaxTokens) return;
-	const clampedBudget = raisedMaxTokens - OUTPUT_FALLBACK_BUFFER;
-	if (clampedBudget <= 0) throw new ConfigurationError(`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${raisedMaxTokens}`);
-	thinking.budget_tokens = clampedBudget;
-}
-function applyCacheControlToLastBlock(blocks, cacheControl) {
-	for (let index = blocks.length - 1; index >= 0; index--) {
-		const block = blocks[index];
-		if (block.type === "thinking" || block.type === "redacted_thinking" || block.type === "fallback" || block.type === "tool_addition" || block.type === "tool_removal") continue;
-		if ("cache_control" in block && block.cache_control != null) return false;
-		blocks[index] = {
-			...block,
-			cache_control: cloneAnthropicCacheControl(cacheControl)
-		};
-		return true;
-	}
-	return false;
-}
-function applyPromptCaching(params, cacheControl) {
-	if (!cacheControl) return;
-	const trailingIndex = params.messages.length - 1;
-	const trailingMessage = params.messages[trailingIndex];
-	const messageEnd = trailingMessage?.role === "user" && trailingMessage.content === "Continue." && params.messages[trailingIndex - 1]?.role === "assistant" ? trailingIndex - 1 : trailingIndex;
-	let eligibleMessages = 0;
-	for (let index = messageEnd; index >= 0 && eligibleMessages < 2; index--) {
-		const message = params.messages[index];
-		if (!message || message.clear_at === "next_user_message") continue;
-		eligibleMessages++;
-		if (typeof message.content === "string") message.content = [{
-			type: "text",
-			text: message.content,
-			cache_control: cloneAnthropicCacheControl(cacheControl)
-		}];
-		else if (Array.isArray(message.content)) applyCacheControlToLastBlock(message.content, cacheControl);
-	}
-}
-/**
-* Anchor cache_control on the stable request head — the last (non-deferred)
-* tool definition and the last system block. The canonical cache order is
-* tools → system → messages, so a breakpoint on the final system block caches
-* the entire tools+system prefix, and the extra tool breakpoint keeps the tool
-* definitions cached even when the system text changes. This guarantees the
-* large, unchanging head is a cache hit on every turn regardless of how the
-* message tail churns — the breakpoint placement first-party Anthropic clients
-* (Claude Code, Pi) use. Without it, the general API-key path anchors only the
-* moving message tail, so tail churn re-writes the whole head uncached.
-*
-* Anthropic allows at most 4 cache breakpoints per request. At most one is
-* spent on tools and one on system here, leaving two for the message tail in
-* `applyPromptCaching`. Head caching is skipped entirely when the head is
-* already anchored — the OAuth Claude Code path caches its own instruction
-* block at buildAnthropicSystemBlocks, and via the canonical tools → system
-* order that single system breakpoint already caches every preceding tool. Re-
-* anchoring there would be redundant, would change the OAuth wire, and could
-* push a tool-heavy request over the 4-breakpoint budget, so the general
-* API-key path (nothing cached upstream) is the only one decorated here.
-*
-* Runs after the byte-stability plane (planStableAnthropicSystem /
-* planStableAnthropicTools), which hands back fresh block/tool copies each turn
-* and keys tool identity off a fingerprint that excludes cache_control — so
-* decorating here is byte-stable across turns and never forces a re-baseline.
-*/
-function applyHeadCaching(systemBlocks, tools, cacheControl) {
-	if (!cacheControl) return;
-	if ((systemBlocks?.some((block) => block.cache_control != null) ?? false) || (tools?.some((tool) => tool.cache_control != null) ?? false)) return;
-	if (tools && tools.length > 0) for (let index = tools.length - 1; index >= 0; index--) {
-		const tool = tools[index];
-		if (!tool || tool.defer_loading) continue;
-		tool.cache_control = cloneAnthropicCacheControl(cacheControl);
-		break;
-	}
-	if (systemBlocks && systemBlocks.length > 0) {
-		const lastBlock = systemBlocks[systemBlocks.length - 1];
-		if (lastBlock) lastBlock.cache_control = cloneAnthropicCacheControl(cacheControl);
-	}
-}
-function usesAdaptiveThinkingTagOnly(model) {
-	const thinking = model.thinking;
-	if (thinking?.mode !== "anthropic-adaptive") return false;
-	const effortMap = thinking.effortMap;
-	if (!effortMap) return false;
-	for (const effort of thinking.efforts) if (effortMap[effort] !== "adaptive") return false;
-	return thinking.efforts.length > 0;
-}
-/**
-* True for adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5)
-* that reject `thinking.type: "disabled"`. Turning thinking off on these models
-* means omitting the `thinking` field entirely and pinning the lowest adaptive
-* effort — a bare omission defaults to adaptive thinking ON. Excludes MiniMax,
-* which drives adaptive thinking through the `thinking.type: "adaptive"` tag
-* itself rather than `output_config.effort`.
-*/
-function isAdaptiveOnlyThinking(model) {
-	return model.thinking?.mode === "anthropic-adaptive" && !model.compat.disableAdaptiveThinking && !usesAdaptiveThinkingTagOnly(model);
-}
-function resolveAnthropicAdaptiveEffort(model, options) {
-	if (options.effort) return usesAdaptiveThinkingTagOnly(model) ? "adaptive" : options.effort;
-	const requestedEffort = options.reasoning;
-	if (!requestedEffort) return void 0;
-	return mapEffortToAnthropicAdaptiveEffort(model, requestedEffort);
-}
-function extractClaudeCodeFirstUserMessageText(messages) {
-	for (const message of messages) {
-		if (message.role !== "user") continue;
-		const { content } = message;
-		if (typeof content === "string") return content;
-		if (!Array.isArray(content)) return "";
-		for (const block of content) if (block.type === "text") return block.text;
-		return "";
-	}
-	return "";
-}
-const MAX_ANTHROPIC_CONTROL_STATES = 16;
-function resetAnthropicControlState(state) {
-	state.declaredTools = void 0;
-	state.activeToolNames.clear();
-	state.stableSystemBlocks = void 0;
-	state.systemFingerprint = void 0;
-	state.controlTransitions = [];
-	state.baseEffort = void 0;
-	state.baseEffortWire = void 0;
-	state.currentEffort = void 0;
-}
-function anthropicControlMessageProjection(message) {
-	if (message.role !== "assistant" || !Array.isArray(message.content)) return message;
-	return {
-		...message,
-		content: message.content.filter((block) => block.type !== "thinking" && block.type !== "redacted_thinking")
-	};
-}
-function getAnthropicControlState(state, sessionId, system, messages) {
-	if (!state) return void 0;
-	const root = messages[0];
-	const fingerprint = String(Bun.hash(JSON.stringify([
-		sessionId ?? "",
-		system?.map((block) => block.text) ?? null,
-		root ? anthropicControlMessageProjection(root) : null
-	])));
-	const existing = state.controlStates.get(fingerprint);
-	if (existing) {
-		state.controlStates.delete(fingerprint);
-		state.controlStates.set(fingerprint, existing);
-		return existing;
-	}
-	const created = createAnthropicControlState();
-	state.controlStates.set(fingerprint, created);
-	if (state.controlStates.size > MAX_ANTHROPIC_CONTROL_STATES) {
-		const oldest = state.controlStates.keys().next().value;
-		if (oldest !== void 0) state.controlStates.delete(oldest);
-	}
-	return created;
-}
-/** Fingerprint of the wire message a control transition is attached after. */
-function anthropicControlAnchor(messages, messageCount) {
-	if (messageCount === 0) return "";
-	const message = messages[messageCount - 1];
-	return message ? String(Bun.hash(JSON.stringify(anthropicControlMessageProjection(message)))) : "";
-}
-/**
-* Discard the control baseline when the request no longer continues the
-* conversation it was captured for: a different model, or a wire history that
-* shrank or was rewritten under a recorded transition (compaction, branch
-* switch, `/clear`). The next request re-baselines from its own payload.
-*/
-function syncAnthropicControlState(state, messages) {
-	for (const transition of state.controlTransitions) if (transition.messageCount > messages.length || transition.anchor !== anthropicControlAnchor(messages, transition.messageCount)) {
-		resetAnthropicControlState(state);
-		return;
-	}
-}
-/**
-* Keep the top-level `system` array byte-stable across a session. The blocks
-* captured on the first request are replayed verbatim (with the current
-* request's cache breakpoints) while their text is unchanged. A text change
-* re-baselines instead of duplicating the prompt as a mid-conversation
-* system message: omp's system prompt is one rendered segment that embeds
-* the tool roster, so replaying a second copy on every later request would
-* cost the full prompt again per change. The prefix rewrite is absorbed by
-* `prefix_mismatch_behavior: "drop_block"` and one cache miss.
-*/
-function planStableAnthropicSystem(current, state, enabled) {
-	if (!state || !enabled) return current;
-	const fingerprint = JSON.stringify(current?.map((block) => block.text) ?? null);
-	if (state.systemFingerprint !== fingerprint) {
-		resetAnthropicControlState(state);
-		state.systemFingerprint = fingerprint;
-		state.stableSystemBlocks = current?.map((block) => ({
-			type: block.type,
-			text: block.text
-		}));
-	}
-	return state.stableSystemBlocks?.map((block, index) => {
-		const cacheControl = current?.[index]?.cache_control;
-		return cacheControl ? {
-			...block,
-			cache_control: cloneAnthropicCacheControl(cacheControl)
-		} : { ...block };
-	});
-}
-function anthropicToolDefinitionKey(tool) {
-	const stable = { ...tool };
-	delete stable.defer_loading;
-	delete stable.description;
-	return JSON.stringify(stable);
-}
-function cloneAnthropicTools(tools) {
-	return tools.map((tool) => ({ ...tool }));
-}
-function recordAnthropicControlTransition(state, messages, messageCount, content, effort) {
-	const existing = state.controlTransitions.findLast((transition) => transition.messageCount === messageCount);
-	if (existing) {
-		existing.content.push(...content);
-		if (effort !== void 0) existing.effort = effort;
-		return;
-	}
-	state.controlTransitions.push({
-		messageCount,
-		anchor: anthropicControlAnchor(messages, messageCount),
-		content,
-		effort
-	});
-}
-/**
-* Keep the top-level `tools` array byte-stable across a session. Tools that
-* leave the active set are withdrawn with `tool_removal`; tools that join are
-* appended with `defer_loading: true` (not part of the checked prefix until
-* referenced) and offered with `tool_addition`. A changed definition for an
-* already-declared name cannot be expressed as a control and re-baselines.
-*/
-function planStableAnthropicTools(current, messages, state, enabled) {
-	if (!state || !enabled || !current) return current;
-	if (!state.declaredTools) {
-		state.declaredTools = cloneAnthropicTools(current);
-		state.activeToolNames = new Set(current.map((tool) => tool.name));
-		return cloneAnthropicTools(state.declaredTools);
-	}
-	const declaredByName = new Map(state.declaredTools.map((tool) => [tool.name, tool]));
-	for (const tool of current) {
-		const declared = declaredByName.get(tool.name);
-		if (declared && anthropicToolDefinitionKey(declared) !== anthropicToolDefinitionKey(tool)) {
-			resetAnthropicControlState(state);
-			state.declaredTools = cloneAnthropicTools(current);
-			state.activeToolNames = new Set(current.map((candidate) => candidate.name));
-			return cloneAnthropicTools(state.declaredTools);
-		}
-	}
-	const nextActive = new Set(current.map((tool) => tool.name));
-	const changes = [];
-	for (const activeName of state.activeToolNames) {
-		if (nextActive.has(activeName)) continue;
-		changes.push({
-			type: "tool_removal",
-			tool: {
-				type: "tool_reference",
-				name: activeName
-			}
-		});
-	}
-	for (const tool of current) {
-		if (state.activeToolNames.has(tool.name)) continue;
-		if (!declaredByName.has(tool.name)) {
-			const deferred = {
-				...tool,
-				defer_loading: true
-			};
-			state.declaredTools.push(deferred);
-			declaredByName.set(tool.name, deferred);
-		}
-		changes.push({
-			type: "tool_addition",
-			tool: {
-				type: "tool_reference",
-				name: tool.name
-			}
-		});
-	}
-	if (changes.length > 0) recordAnthropicControlTransition(state, messages, messages.length, changes);
-	state.activeToolNames = nextActive;
-	return cloneAnthropicTools(state.declaredTools);
-}
-/**
-* Keep top-level `output_config.effort` byte-stable across a session and carry
-* later changes as per-message effort. Anthropic applies a system message's
-* `output_config.effort` from the next `user` turn on, so the control is
-* anchored before the latest user message to take effect on this response.
-*/
-function planStableAnthropicEffort(current, messages, state, enabled) {
-	if (!state || !enabled) return current;
-	const effective = current ?? "high";
-	if (state.baseEffort === void 0) {
-		state.baseEffort = effective;
-		state.baseEffortWire = current;
-		state.currentEffort = effective;
-		return current;
-	}
-	if (state.currentEffort !== effective) {
-		const lastUserIndex = messages.findLastIndex((message) => message.role === "user");
-		recordAnthropicControlTransition(state, messages, lastUserIndex >= 0 ? lastUserIndex : messages.length, [], effective);
-		state.currentEffort = effective;
-	}
-	return state.baseEffortWire;
-}
-function materializeAnthropicControlTransitions(messages, state) {
-	if (!state || state.controlTransitions.length === 0) return messages;
-	const result = messages.slice();
-	const ordered = state.controlTransitions.toSorted((a, b) => a.messageCount - b.messageCount);
-	let offset = 0;
-	for (const transition of ordered) {
-		const index = Math.min(transition.messageCount + offset, result.length);
-		const previous = result[index - 1];
-		if (previous?.role === "system" && previous.clear_at === void 0) {
-			const content = typeof previous.content === "string" ? [{
-				type: "text",
-				text: previous.content
-			}, ...transition.content] : [...previous.content, ...transition.content];
-			result[index - 1] = {
-				...previous,
-				content,
-				...transition.effort === void 0 ? {} : { output_config: { effort: transition.effort } }
-			};
-			continue;
-		}
-		result.splice(index, 0, {
-			role: "system",
-			content: transition.content.map((block) => ({ ...block })),
-			...transition.effort === void 0 ? {} : { output_config: { effort: transition.effort } }
-		});
-		offset++;
-	}
-	return result;
-}
-function buildParams(model, context, isOAuthToken, options, buildOptions) {
-	const { disableStrictTools, useUmansGatewayWebSearch, forceDemoteUnsignedThinking, supportsEagerToolInputStreaming, prefixMismatchBehavior, dropAllThinking, droppedThinkingBlocks, providerSessionState, fallbacks = options?.fallbacks } = buildOptions;
-	const effectiveModel = forceDemoteUnsignedThinking && model.compat.replayUnsignedThinking ? {
-		...model,
-		compat: {
-			...model.compat,
-			replayUnsignedThinking: false
-		}
-	} : model;
-	const { cacheControl } = getCacheControl(model, options?.cacheRetention);
-	const shouldInjectClaudeCodeInstruction = isOAuthToken && model.compat.injectClaudeCodeInstruction !== false;
-	const firstUserMessageText = shouldInjectClaudeCodeInstruction ? extractClaudeCodeFirstUserMessageText(context.messages) : "";
-	let systemBlocks = buildAnthropicSystemBlocks(context.systemPrompt, {
-		includeClaudeCodeInstruction: shouldInjectClaudeCodeInstruction,
-		firstUserMessageText,
-		cacheControl
-	});
-	let tools;
-	if (context.tools) tools = convertTools(context.tools, isOAuthToken, disableStrictTools, supportsEagerToolInputStreaming, model.compat.escapeBuiltinToolNames, useUmansGatewayWebSearch);
-	else if (isOAuthToken) tools = [];
-	const metadataAccountId = readAnthropicMetadataAccountId(options?.metadata);
-	const metadataUserId = resolveAnthropicMetadataUserId(readMetadataString(options?.metadata, "user_id") ?? (model.provider === "kimi-code" ? getOpenAIPromptCacheKey(options) : void 0), isOAuthToken, options?.sessionId, metadataAccountId);
-	const metadata = metadataUserId ? { user_id: metadataUserId } : void 0;
-	let thinking;
-	let outputConfigEffort;
-	if (model.reasoning) {
-		if (options?.thinkingEnabled || model.compat.requiresThinkingEnabled) {
-			const thinkingOptions = options ?? {};
-			const mode = model.thinking?.mode;
-			const effort = resolveAnthropicAdaptiveEffort(model, thinkingOptions);
-			const compat = model.compat;
-			if (mode === "anthropic-adaptive" && !compat.disableAdaptiveThinking) {
-				const adaptive = { type: "adaptive" };
-				if (model.thinking?.supportsDisplay) adaptive.display = thinkingOptions.thinkingDisplay ?? "summarized";
-				thinking = adaptive;
-				if (effort && effort !== "adaptive") outputConfigEffort = effort;
-			} else {
-				thinking = {
-					type: "enabled",
-					budget_tokens: thinkingOptions.thinkingBudgetTokens || 1024,
-					display: thinkingOptions.thinkingDisplay ?? "summarized"
-				};
-				if (mode === "anthropic-budget-effort" && effort && effort !== "adaptive") outputConfigEffort = effort;
-			}
-		} else if (options?.thinkingEnabled === false) {
-			if (isAdaptiveOnlyThinking(model)) outputConfigEffort = "low";
-			else thinking = { type: "disabled" };
-		}
-	}
-	if (prefixMismatchBehavior) {
-		if (!thinking && model.thinking?.mode === "anthropic-adaptive") thinking = { type: "adaptive" };
-		if (thinking?.type === "adaptive" || thinking?.type === "enabled") thinking.block_binding = { prefix_mismatch_behavior: prefixMismatchBehavior };
-	}
-	const contextManagement = !options?.client && model.compat.supportsContextManagement !== false && (thinking?.type === "adaptive" || thinking?.type === "enabled") ? { edits: [{
-		type: "clear_thinking_20251015",
-		keep: "all"
-	}] } : void 0;
-	let wireMessages = convertAnthropicMessages(context.messages, effectiveModel, isOAuthToken, {
-		serverSideFallbackEnabled: !!fallbacks?.length,
-		dropAllThinking,
-		droppedThinkingBlocks
-	});
-	const controlState = getAnthropicControlState(providerSessionState, options?.sessionId, systemBlocks, wireMessages);
-	if (controlState) syncAnthropicControlState(controlState, wireMessages);
-	systemBlocks = planStableAnthropicSystem(systemBlocks, controlState, model.compat.supportsMidConversationSystem);
-	tools = planStableAnthropicTools(tools, wireMessages, controlState, model.compat.supportsMidConversationToolChanges);
-	applyHeadCaching(systemBlocks, tools, cacheControl);
-	const topLevelEffort = planStableAnthropicEffort(outputConfigEffort, wireMessages, controlState, model.compat.supportsPerMessageEffort);
-	wireMessages = materializeAnthropicControlTransitions(wireMessages, controlState);
-	const outputConfigEntries = {};
-	if (topLevelEffort && model.compat.supportsOutputEffort) outputConfigEntries.effort = topLevelEffort;
-	if (options?.taskBudget) outputConfigEntries.task_budget = options.taskBudget;
-	const outputConfig = Object.keys(outputConfigEntries).length ? outputConfigEntries : void 0;
-	const modelMaxTokens = model.maxTokens ?? 64e3;
-	const maxOutputTokens = isOAuthToken ? Math.min(CLAUDE_CODE_MAX_OUTPUT_TOKENS, modelMaxTokens) : modelMaxTokens;
-	const vertexControlBetas = isVertexRawPredictUrl(model.baseUrl) ? resolveAnthropicControlBetas(model, prefixMismatchBehavior) : [];
-	const params = {
-		model: options?.requestModelId ?? model.requestModelId ?? model.id,
-		messages: wireMessages,
-		...systemBlocks && { system: systemBlocks },
-		...tools !== void 0 && { tools },
-		...metadata && { metadata },
-		max_tokens: Math.min(maxOutputTokens, options?.maxTokens ?? modelMaxTokens),
-		...thinking && { thinking },
-		...contextManagement && { context_management: contextManagement },
-		...outputConfig && { output_config: outputConfig },
-		...fallbacks?.length ? { fallbacks } : {},
-		...vertexControlBetas.length > 0 ? { anthropic_beta: vertexControlBetas } : {},
-		stream: true
-	};
-	const thinkingType = params.thinking?.type;
-	const allowSamplingParams = model.compat.supportsSamplingParams && (thinkingType === void 0 || thinkingType === "disabled");
-	if (allowSamplingParams && options?.temperature !== void 0) params.temperature = options.temperature;
-	if (allowSamplingParams && options?.topP !== void 0) params.top_p = options.topP;
-	if (allowSamplingParams && options?.topK !== void 0) params.top_k = options.topK;
-	if (options?.stopSequences?.length) {
-		const seqs = options.stopSequences;
-		if (seqs.length > ANTHROPIC_STOP_SEQUENCES_MAX && !warnedStopSequencesTrim) {
-			warnedStopSequencesTrim = true;
-			warn("anthropic: stop_sequences exceeds 4; extra entries dropped", {
-				received: seqs.length,
-				kept: ANTHROPIC_STOP_SEQUENCES_MAX
-			});
-		}
-		params.stop_sequences = seqs.length > ANTHROPIC_STOP_SEQUENCES_MAX ? seqs.slice(0, ANTHROPIC_STOP_SEQUENCES_MAX) : seqs;
-	}
-	if (model.provider === "anthropic" && options?.serviceTier === "priority") params.speed = "fast";
-	if (options?.toolChoice) {
-		if (typeof options.toolChoice === "string") params.tool_choice = { type: options.toolChoice };
-		else if (options.toolChoice.name) params.tool_choice = {
-			...options.toolChoice,
-			name: encodeAnthropicToolName(options.toolChoice.name, isOAuthToken, model.compat.escapeBuiltinToolNames, useUmansGatewayWebSearch)
-		};
-		const choiceType = params.tool_choice?.type;
-		if ((choiceType === "any" || choiceType === "tool") && !model.compat.supportsForcedToolChoice) params.tool_choice = { type: "auto" };
-	}
-	disableThinkingIfToolChoiceForced(params, model);
-	ensureMaxTokensForThinking(params, maxOutputTokens);
-	applyPromptCaching(params, cacheControl);
-	return params;
-}
-const EMPTY_ERROR_TOOL_RESULT_TEXT = "Tool failed with no output.";
-function isEmptyToolResultWireContent(content) {
-	if (typeof content === "string") return content.trim().length === 0;
-	return content.length === 0;
-}
-function ensureErrorToolResultWireContent(content, isError) {
-	if (!isError || !isEmptyToolResultWireContent(content)) return content;
-	return typeof content === "string" ? EMPTY_ERROR_TOOL_RESULT_TEXT : [{
-		type: "text",
-		text: EMPTY_ERROR_TOOL_RESULT_TEXT
-	}];
-}
-function buildToolResultBlock(model, msg, hoistedImages) {
-	let content = convertContentBlocks(msg.content, model.input.includes("image"));
-	if (msg.isError && typeof content !== "string" && content.some((block) => block.type === "image")) {
-		for (const block of content) if (block.type === "image") hoistedImages.push(block);
-		content = content.filter((block) => block.type === "text");
-	}
-	if (Array.isArray(content) && content.length === 0) content = "";
-	content = ensureErrorToolResultWireContent(content, msg.isError);
-	const block = {
-		type: "tool_result",
-		tool_use_id: msg.toolCallId,
-		content,
-		is_error: msg.isError
-	};
-	if (model.compat.requiresToolResultId) block.id = msg.toolCallId;
-	return block;
-}
-/**
-* Recursively replace lone surrogates in string leaves. Identity-preserving:
-* returns the input object/array when nothing changed.
-*/
-function toWellFormedDeep(value) {
-	if (typeof value === "string") {
-		const wellFormed = value.toWellFormed();
-		return wellFormed === value ? value : wellFormed;
-	}
-	if (Array.isArray(value)) {
-		let changed = false;
-		const next = value.map((entry) => {
-			const sanitized = toWellFormedDeep(entry);
-			if (sanitized !== entry) changed = true;
-			return sanitized;
-		});
-		return changed ? next : value;
-	}
-	if (isRecord(value)) {
-		let changed = false;
-		const next = {};
-		for (const [key, entry] of Object.entries(value)) {
-			const sanitized = toWellFormedDeep(entry);
-			if (sanitized !== entry) changed = true;
-			next[key] = sanitized;
-		}
-		return changed ? next : value;
-	}
-	return value;
-}
-/**
-* Serialize omp {@link Message}s to Anthropic wire messages.
-*
-* `opts.serverSideFallbackEnabled` — when the CURRENT request itself
-* opts into the server-side-fallback beta chain. Only then may a persisted
-* `fallback` content block from a prior turn be replayed on the wire;
-* otherwise the block is dropped to avoid a 400 on non-fallback requests
-* that don't send the beta.
-*/
-function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
-	const developerParams = [];
-	const params = [];
-	const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
-	for (let i = 0; i < transformedMessages.length; i++) {
-		const msg = transformedMessages[i];
-		if (msg.role === "user" || msg.role === "developer") {
-			const payload = msg.role === "developer" && msg.providerPayload?.type === "anthropicMessage" ? msg.providerPayload : void 0;
-			const hasProviderControls = payload?.clearAt !== void 0 || payload?.effort !== void 0 || payload?.toolChanges !== void 0 && payload.toolChanges.length > 0;
-			let content;
-			if (typeof msg.content === "string") {
-				if (msg.content.trim().length === 0) {
-					if (!hasProviderControls) continue;
-					content = [];
-				} else content = msg.content.toWellFormed();
-			} else {
-				const contentBlocks = convertContentBlocks(msg.content, model.input.includes("image"));
-				if (typeof contentBlocks === "string") {
-					if (contentBlocks.trim().length === 0) {
-						if (!hasProviderControls) continue;
-						content = [];
-					} else content = contentBlocks;
-				} else {
-					if (contentBlocks.length === 0 && !hasProviderControls) continue;
-					content = contentBlocks;
-				}
-			}
-			if (payload?.toolChanges && model.compat.supportsMidConversationToolChanges) {
-				const blocks = typeof content === "string" ? [{
-					type: "text",
-					text: content
-				}] : content;
-				for (const change of payload.toolChanges) blocks.push({
-					type: change.type,
-					tool: {
-						type: "tool_reference",
-						name: encodeAnthropicToolName(change.name, isOAuthToken, model.compat.escapeBuiltinToolNames)
-					}
-				});
-				content = blocks;
-			}
-			if (msg.role === "developer") developerParams.push({
-				index: params.length,
-				payload
-			});
-			params.push({
-				role: "user",
-				content
-			});
-		} else if (msg.role === "assistant") {
-			const blocks = [];
-			const hasSignedThinking = msg.content.some((block) => block.type === "thinking" && !!block.thinkingSignature && block.thinkingSignature.trim().length > 0);
-			for (const block of msg.content) if (block.type === "text") {
-				if (block.text.trim().length === 0) continue;
-				blocks.push({
-					type: "text",
-					text: block.text.toWellFormed()
-				});
-			} else if (block.type === "thinking") {
-				if (opts?.dropAllThinking || block.thinkingSignature && opts?.droppedThinkingBlocks?.has(`thinking:${block.thinkingSignature}`)) continue;
-				if (hasSignedThinking) {
-					if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-						if (block.thinking.trim().length === 0) continue;
-						blocks.push({
-							type: "text",
-							text: renderDemotedThinking(model.id, block.thinking)
-						});
-						continue;
-					}
-					blocks.push({
-						type: "thinking",
-						thinking: block.thinking,
-						signature: block.thinkingSignature
-					});
-					continue;
-				}
-				if (block.thinking.trim().length === 0) continue;
-				if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-					if (model.compat.replayUnsignedThinking) blocks.push({
-						type: "thinking",
-						thinking: block.thinking.toWellFormed(),
-						signature: ""
-					});
-					else blocks.push({
-						type: "text",
-						text: renderDemotedThinking(model.id, block.thinking)
-					});
-				} else blocks.push({
-					type: "thinking",
-					thinking: block.thinking.toWellFormed(),
-					signature: block.thinkingSignature
-				});
-			} else if (block.type === "redactedThinking") {
-				if (opts?.dropAllThinking || opts?.droppedThinkingBlocks?.has(`redacted:${block.data}`)) continue;
-				if (block.data.trim().length === 0) continue;
-				blocks.push({
-					type: "redacted_thinking",
-					data: block.data
-				});
-			} else if (block.type === "anthropicServerTool") blocks.push(block.block);
-			else if (block.type === "fallback") {
-				if (!opts?.serverSideFallbackEnabled || !model.compat.officialEndpoint) continue;
-				blocks.push({
-					type: "fallback",
-					from: block.from,
-					to: block.to
-				});
-			} else if (block.type === "toolCall") blocks.push({
-				type: "tool_use",
-				id: block.id,
-				name: encodeAnthropicToolName(block.name, isOAuthToken, model.compat.escapeBuiltinToolNames),
-				input: toWellFormedDeep(block.arguments ?? {})
-			});
-			let sawToolUse = false;
-			let needsPartition = false;
-			for (const block of blocks) if (block.type === "tool_use") sawToolUse = true;
-			else if (sawToolUse && block.type !== "thinking" && block.type !== "redacted_thinking") {
-				needsPartition = true;
-				break;
-			}
-			if (needsPartition) {
-				const nonToolUse = [];
-				const toolUse = [];
-				for (const block of blocks) if (block.type === "tool_use") toolUse.push(block);
-				else nonToolUse.push(block);
-				blocks.length = 0;
-				blocks.push(...nonToolUse, ...toolUse);
-			}
-			if (blocks.length === 0) continue;
-			params.push({
-				role: "assistant",
-				content: blocks
-			});
-		} else if (msg.role === "toolResult") {
-			const toolResults = [];
-			const hoistedImages = [];
-			toolResults.push(buildToolResultBlock(model, msg, hoistedImages));
-			let j = i + 1;
-			while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-				const nextMsg = transformedMessages[j];
-				toolResults.push(buildToolResultBlock(model, nextMsg, hoistedImages));
-				j++;
-			}
-			i = j - 1;
-			if (hoistedImages.length > 0) toolResults.push({
-				type: "text",
-				text: "Attached image(s) from the tool result(s) above:"
-			}, ...hoistedImages);
-			params.push({
-				role: "user",
-				content: toolResults
-			});
-		}
-	}
-	if (developerParams.length > 0 && model.compat.supportsMidConversationSystem) for (const developer of developerParams.toReversed()) {
-		const idx = developer.index;
-		const followsUser = idx > 0 && params[idx - 1]?.role === "user";
-		const next = params[idx + 1];
-		const lastOrBeforeAssistant = idx === params.length - 1 || next?.role === "assistant";
-		const content = params[idx].content;
-		const systemCompatible = typeof content === "string" || content.every((block) => block.type === "text" || block.type === "tool_addition" || block.type === "tool_removal");
-		const effortOnly = developer.payload?.effort !== void 0 && Array.isArray(content) && content.length === 0;
-		if (!(followsUser && lastOrBeforeAssistant && systemCompatible || effortOnly)) continue;
-		const turnScoped = developer.payload?.clearAt === "next_user_message" && model.compat.supportsTurnScopedSystem;
-		const hasEffort = developer.payload?.effort !== void 0 && model.compat.supportsPerMessageEffort;
-		const hasToolChanges = (developer.payload?.toolChanges?.length ?? 0) > 0;
-		if (turnScoped && (hasEffort || hasToolChanges) && Array.isArray(content)) {
-			const scopedContent = content.filter((block) => block.type === "text");
-			const controlContent = content.filter((block) => block.type !== "text");
-			if (scopedContent.length > 0) {
-				params[idx] = {
-					role: "system",
-					content: scopedContent,
-					clear_at: "next_user_message"
-				};
-				params.splice(idx + 1, 0, {
-					role: "system",
-					content: controlContent,
-					...hasEffort ? { output_config: { effort: developer.payload?.effort } } : {}
-				});
-				continue;
-			}
-		}
-		params[idx] = {
-			role: "system",
-			content,
-			...turnScoped && !hasEffort && !hasToolChanges ? { clear_at: "next_user_message" } : {},
-			...hasEffort ? { output_config: { effort: developer.payload?.effort } } : {}
-		};
-	}
-	for (let i = params.length - 1; i > 0; i--) if (params[i].role === "assistant" && params[i - 1]?.role === "assistant") params.splice(i, 0, {
-		role: "user",
-		content: "Continue."
-	});
-	if (params.length > 0 && params[params.length - 1]?.role === "assistant") params.push({
-		role: "user",
-		content: "Continue."
-	});
-	return params;
-}
-/**
-* JSON Schema whitelist for Anthropic tool `input_schema` nodes.
-*
-* Tracks the Anthropic Python SDK's `lib/_parse/_transform.py::transform_schema`,
-* with live Messages API guardrails for keywords the SDK preserves but the API rejects.
-* We keep only structural/metadata keywords Anthropic's validator honors, and demote
-* anything else into the node's `description` as `\n\n{key: value, ...}` so the model
-* still sees the constraint as a natural-language hint.
-*
-* `Set` (not `Record<string, true>`) because membership is probed against arbitrary
-* user/Zod-derived schema keys: a literal Record would falsely match prototype names
-* like `"toString"` and silently strip valid properties.
-*/
-const ANTHROPIC_TOOL_SCHEMA_UNIVERSAL_KEEP = /* @__PURE__ */ new Set([
-	"$ref",
-	"$defs",
-	"$schema",
-	"definitions",
-	"type",
-	"anyOf",
-	"allOf",
-	"enum",
-	"const",
-	"description",
-	"title",
-	"default",
-	"nullable"
-]);
-/** Keys preserved on `type: "object"` nodes (in addition to the universal set). */
-const ANTHROPIC_TOOL_SCHEMA_OBJECT_KEEP = /* @__PURE__ */ new Set([
-	"properties",
-	"required",
-	"additionalProperties"
-]);
-/** Keys preserved on `type: "array"` nodes; `minItems` only when its value is 0 or 1. */
-const ANTHROPIC_TOOL_SCHEMA_ARRAY_KEEP = /* @__PURE__ */ new Set([
-	"items",
-	"prefixItems",
-	"minItems"
-]);
-/** Keys preserved on `type: "string"` nodes; `format` only when its value is in the supported list. */
-const ANTHROPIC_TOOL_SCHEMA_STRING_KEEP = /* @__PURE__ */ new Set(["format"]);
-/**
-* String `format` values Anthropic accepts; everything else (including `pattern`-style
-* format hints) gets demoted into `description`. Matches `SupportedStringFormats` in the
-* Anthropic SDK's `_transform.py`.
-*/
-const ANTHROPIC_TOOL_SCHEMA_STRING_FORMATS = /* @__PURE__ */ new Set([
-	"date-time",
-	"time",
-	"date",
-	"duration",
-	"email",
-	"hostname",
-	"uri",
-	"ipv4",
-	"ipv6",
-	"uuid"
-]);
-const ANTHROPIC_STRICT_TOOL_ALLOWLIST = /* @__PURE__ */ new Set([
-	"bash",
-	"python",
-	"edit",
-	"find"
-]);
-const MAX_ANTHROPIC_STRICT_TOOLS = 20;
-const MAX_ANTHROPIC_STRICT_OPTIONAL_PARAMETERS = 24;
-const MAX_ANTHROPIC_STRICT_UNION_PARAMETERS = 16;
-/** `minItems` / `maxItems` apply to arrays; Anthropic rejects them on `type: "object"` (including `minItems: 0`/`1`). */
-function isJsonSchemaArrayNode(schema) {
-	const t = schema.type;
-	if (t === "array") return true;
-	if (Array.isArray(t) && t.includes("array") && !t.includes("object")) return true;
-	if (schema.items !== void 0 || Array.isArray(schema.prefixItems)) return true;
-	return false;
-}
-function isJsonSchemaObjectNode(schema) {
-	if (isJsonSchemaArrayNode(schema)) return false;
-	if (schema.type === "object") return true;
-	if (Array.isArray(schema.type) && schema.type.includes("object")) return true;
-	if (isRecord(schema.properties)) return true;
-	return false;
-}
-/**
-* Pick the principal non-null scalar type from a `type` keyword. Anthropic accepts
-* `type` as either a single string or an array (e.g. `["number", "null"]` for a
-* nullable value); the SDK whitelist is keyed off the scalar type, with `"null"`
-* ignored so nullable variants are normalized as their underlying type.
-*/
-function pickAnthropicScalarType(type) {
-	if (typeof type === "string") return type;
-	if (Array.isArray(type)) {
-		for (const entry of type) if (typeof entry === "string" && entry !== "null") return entry;
-	}
-}
-function pickAnthropicEffectiveScalarType(schema) {
-	const explicit = pickAnthropicScalarType(schema.type);
-	if (explicit) return explicit;
-	if (isRecord(schema.properties)) return "object";
-	if (schema.items !== void 0 || Array.isArray(schema.prefixItems)) return "array";
-}
-function anthropicPerTypeKeep(scalarType) {
-	switch (scalarType) {
-		case "object": return ANTHROPIC_TOOL_SCHEMA_OBJECT_KEEP;
-		case "array": return ANTHROPIC_TOOL_SCHEMA_ARRAY_KEEP;
-		case "string": return ANTHROPIC_TOOL_SCHEMA_STRING_KEEP;
-		default: return;
-	}
-}
-/**
-* Normalize a JSON Schema node for Anthropic tool `input_schema`.
-*
-* Applies the full whitelist semantics from the Anthropic Python SDK's
-* `lib/_parse/_transform.py::transform_schema`:
-*
-* 1. Universal keys (`$ref`, `$defs`, `type`, `anyOf`, `allOf`, `enum`, `const`,
-*    `description`, `title`, `default`, `nullable`) are preserved on every node, with
-*    one position-dependent exception: the combinator keys. Root `anyOf`/`allOf` are
-*    spilled (recent Anthropic Messages validators reject combinators at the tool
-*    `input_schema` root) but kept when nested; `oneOf` is spilled at every position
-*    (it is not in the documented supported subset).
-* 2. Per-type keys are kept additively (object → `properties`/`required`/`additionalProperties`,
-*    array → `items`/`prefixItems` plus `minItems` only when 0 or 1, string → `format`
-*    only when in the supported value set).
-* 3. Everything else is demoted into the node's `description` as `\n\n{key: value, ...}`
-*
-* Object nodes default to `additionalProperties: false`, but explicit open-map
-* declarations (`additionalProperties: true` or a schema literal — Zod's
-* `z.record(z.string(), z.unknown())` produces `{}`) are preserved. The strict-mode
-* pass downstream demotes those shapes to non-strict instead of fabricating a closed
-* object, so callers like the resolve tool keep working open-map semantics.
-*/
-function normalizeAnthropicToolSchemaNode(schema, cache, isRoot = false) {
-	if (Array.isArray(schema)) return schema.map((entry) => normalizeAnthropicToolSchemaNode(entry, cache));
-	if (!isRecord(schema)) return schema;
-	const existing = cache.get(schema);
-	if (existing !== void 0) return existing;
-	const result = {};
-	cache.set(schema, result);
-	const scalarType = pickAnthropicEffectiveScalarType(schema);
-	const perTypeKeep = anthropicPerTypeKeep(scalarType);
-	const spill = [];
-	for (const key in schema) {
-		if (!Object.hasOwn(schema, key)) continue;
-		const value = schema[key];
-		if (!(isRoot && COMBINATOR_KEYS.includes(key)) && (ANTHROPIC_TOOL_SCHEMA_UNIVERSAL_KEEP.has(key) || perTypeKeep?.has(key))) result[key] = value;
-		else spill.push([key, value]);
-	}
-	if (scalarType === "string") {
-		const format = result.format;
-		if (typeof format === "string" && !ANTHROPIC_TOOL_SCHEMA_STRING_FORMATS.has(format)) {
-			spill.push(["format", format]);
-			delete result.format;
-		}
-	}
-	if (scalarType === "array" && result.minItems !== void 0) {
-		const minItems = result.minItems;
-		if (!(typeof minItems === "number" && (minItems === 0 || minItems === 1))) {
-			spill.push(["minItems", minItems]);
-			delete result.minItems;
-		}
-	}
-	if (scalarType === "object" && result.additionalProperties === void 0) result.additionalProperties = false;
-	if (isRecord(result.properties)) {
-		const normalizedProperties = {};
-		const sourceProperties = result.properties;
-		for (const propName in sourceProperties) {
-			if (!Object.hasOwn(sourceProperties, propName)) continue;
-			normalizedProperties[propName] = normalizeAnthropicToolSchemaNode(sourceProperties[propName], cache);
-		}
-		result.properties = normalizedProperties;
-	}
-	if (isRecord(result.additionalProperties)) {
-		const normalized = normalizeAnthropicToolSchemaNode(result.additionalProperties, cache);
-		if (isRecord(normalized) && Object.keys(normalized).length === 0) result.additionalProperties = true;
-		else result.additionalProperties = normalized;
-	}
-	if (Array.isArray(result.items)) result.items = result.items.map((item) => normalizeAnthropicToolSchemaNode(item, cache));
-	else if (isRecord(result.items)) result.items = normalizeAnthropicToolSchemaNode(result.items, cache);
-	if (Array.isArray(result.prefixItems)) result.prefixItems = result.prefixItems.map((item) => normalizeAnthropicToolSchemaNode(item, cache));
-	for (const key of COMBINATOR_KEYS) {
-		const variants = result[key];
-		if (Array.isArray(variants)) result[key] = variants.map((variant) => normalizeAnthropicToolSchemaNode(variant, cache));
-	}
-	for (const defsKey of ["$defs", "definitions"]) {
-		const definitions = result[defsKey];
-		if (!isRecord(definitions)) continue;
-		const normalizedDefs = {};
-		const sourceDefs = definitions;
-		for (const name in sourceDefs) {
-			if (!Object.hasOwn(sourceDefs, name)) continue;
-			normalizedDefs[name] = normalizeAnthropicToolSchemaNode(sourceDefs[name], cache);
-		}
-		result[defsKey] = normalizedDefs;
-	}
-	spillToDescription(result, spill);
-	return result;
-}
-function normalizeAnthropicToolSchema(schema) {
-	return normalizeAnthropicToolSchemaNode(schema, /* @__PURE__ */ new WeakMap(), true);
-}
-function hasAnthropicUnionType(schema) {
-	return Array.isArray(schema.type) || Array.isArray(schema.anyOf);
-}
-function hasNullVariant(schema) {
-	if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
-	return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => isRecord(variant) && variant.type === "null");
-}
-function hasAnthropicSchemaDefiningKeyword(schema) {
-	if (schema.type !== void 0 || schema.properties !== void 0 || schema.additionalProperties !== void 0 || schema.items !== void 0 || schema.prefixItems !== void 0 || schema.enum !== void 0 || schema.const !== void 0 || schema.$ref !== void 0) return true;
-	for (const key of COMBINATOR_KEYS) if (schema[key] !== void 0) return true;
-	return schema.$defs !== void 0 || schema.definitions !== void 0;
-}
-function makeAnthropicNullableSchema(schema, budget) {
-	if (isRecord(schema)) {
-		if (hasNullVariant(schema)) return schema;
-		if (Array.isArray(schema.anyOf)) return {
-			...schema,
-			anyOf: [...schema.anyOf, { type: "null" }]
-		};
-		if (Array.isArray(schema.type)) return {
-			...schema,
-			type: [...schema.type, "null"]
-		};
-	}
-	if (budget.unionRemaining <= 0) return void 0;
-	budget.unionRemaining--;
-	budget.unionCount++;
-	return { anyOf: [schema, { type: "null" }] };
-}
-function normalizeAnthropicStrictSchemaNode(schema, budget, cache) {
-	if (Array.isArray(schema)) {
-		const result = [];
-		for (const entry of schema) {
-			const normalized = normalizeAnthropicStrictSchemaNode(entry, budget, cache);
-			if (normalized === void 0) return void 0;
-			result.push(normalized);
-		}
-		return result;
-	}
-	if (!isRecord(schema)) return schema;
-	const cached = cache.get(schema);
-	if (cached) return cached;
-	if (!hasAnthropicSchemaDefiningKeyword(schema)) return void 0;
-	if (isJsonSchemaObjectNode(schema) && schema.additionalProperties !== false) return;
-	const result = { ...schema };
-	cache.set(schema, result);
-	if (hasAnthropicUnionType(result)) {
-		if (budget.unionRemaining <= 0) return void 0;
-		budget.unionRemaining--;
-		budget.unionCount++;
-	}
-	if (isRecord(result.properties)) {
-		const originalRequired = new Set(Array.isArray(result.required) ? result.required.filter((entry) => typeof entry === "string") : []);
-		const properties = {};
-		const required = [];
-		for (const [propertyName, propertySchema] of Object.entries(result.properties)) {
-			const normalizedProperty = normalizeAnthropicStrictSchemaNode(propertySchema, budget, cache);
-			if (normalizedProperty === void 0) return void 0;
-			if (originalRequired.has(propertyName)) {
-				properties[propertyName] = normalizedProperty;
-				required.push(propertyName);
-				continue;
-			}
-			if (budget.optionalRemaining > 0) {
-				budget.optionalRemaining--;
-				budget.optionalCount++;
-				properties[propertyName] = normalizedProperty;
-				continue;
-			}
-			const nullableProperty = makeAnthropicNullableSchema(normalizedProperty, budget);
-			if (nullableProperty === void 0) return void 0;
-			properties[propertyName] = nullableProperty;
-			required.push(propertyName);
-		}
-		result.properties = properties;
-		result.required = required;
-	}
-	if (Array.isArray(result.items)) {
-		const items = normalizeAnthropicStrictSchemaNode(result.items, budget, cache);
-		if (items === void 0) return void 0;
-		result.items = items;
-	} else if (isRecord(result.items)) {
-		const items = normalizeAnthropicStrictSchemaNode(result.items, budget, cache);
-		if (items === void 0) return void 0;
-		result.items = items;
-	}
-	if (Array.isArray(result.prefixItems)) {
-		const prefixItems = normalizeAnthropicStrictSchemaNode(result.prefixItems, budget, cache);
-		if (prefixItems === void 0) return void 0;
-		result.prefixItems = prefixItems;
-	}
-	for (const key of COMBINATOR_KEYS) {
-		const variants = result[key];
-		if (!Array.isArray(variants)) continue;
-		const normalizedVariants = normalizeAnthropicStrictSchemaNode(variants, budget, cache);
-		if (normalizedVariants === void 0) return void 0;
-		result[key] = normalizedVariants;
-	}
-	for (const defsKey of ["$defs", "definitions"]) {
-		const definitions = result[defsKey];
-		if (!isRecord(definitions)) continue;
-		const normalizedDefinitions = {};
-		for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
-			const normalizedDefinition = normalizeAnthropicStrictSchemaNode(definitionSchema, budget, cache);
-			if (normalizedDefinition === void 0) return void 0;
-			normalizedDefinitions[definitionName] = normalizedDefinition;
-		}
-		result[defsKey] = normalizedDefinitions;
-	}
-	return result;
-}
-const ANTHROPIC_STRICT_INCOMPATIBLE_KEYWORDS = [
-	"oneOf",
-	"allOf",
-	"$ref",
-	"patternProperties",
-	"propertyNames"
-];
-/**
-* Anthropic's strict grammar subset supports anyOf/type-array unions only.
-* oneOf/allOf/$ref compile unpredictably (rejections arrive as 400s the
-* grammar-too-large fallback does not recognize, so they would hard-fail the
-* turn), and patternProperties/propertyNames describe open key sets that the
-* strict pipeline's injected `additionalProperties: false` would contradict.
-* Runs against the raw wire schema — the base normalizer spills several of
-* these keywords into the description, erasing the evidence.
-*/
-function hasAnthropicStrictIncompatibleKeyword(schema, seen = /* @__PURE__ */ new Set()) {
-	if (Array.isArray(schema)) {
-		if (seen.has(schema)) return false;
-		seen.add(schema);
-		return schema.some((entry) => hasAnthropicStrictIncompatibleKeyword(entry, seen));
-	}
-	if (!isRecord(schema)) return false;
-	if (seen.has(schema)) return false;
-	seen.add(schema);
-	for (const keyword of ANTHROPIC_STRICT_INCOMPATIBLE_KEYWORDS) if (schema[keyword] !== void 0) return true;
-	return Object.values(schema).some((value) => hasAnthropicStrictIncompatibleKeyword(value, seen));
-}
-function normalizeAnthropicStrictSchema(schema, optionalRemaining, unionRemaining) {
-	const budget = {
-		optionalRemaining,
-		unionRemaining,
-		optionalCount: 0,
-		unionCount: 0
-	};
-	const normalized = normalizeAnthropicStrictSchemaNode(schema, budget, /* @__PURE__ */ new WeakMap());
-	if (!isRecord(normalized)) return void 0;
-	return {
-		schema: normalized,
-		optionalCount: budget.optionalCount,
-		unionCount: budget.unionCount
-	};
-}
-function buildAnthropicBaseToolInputSchema(tool) {
-	const jsonSchema = toolWireSchema(tool);
-	return normalizeAnthropicToolSchema({
-		...jsonSchema,
-		type: "object",
-		properties: isRecord(jsonSchema.properties) ? jsonSchema.properties : {},
-		required: Array.isArray(jsonSchema.required) ? jsonSchema.required.filter((entry) => typeof entry === "string") : []
-	});
-}
-function buildAnthropicToolSchemaPlans(tools, disableStrictTools = false) {
-	const plans = tools.map((tool) => ({
-		inputSchema: buildAnthropicBaseToolInputSchema(tool),
-		strict: false
-	}));
-	if (NO_STRICT || disableStrictTools) return plans;
-	const candidateIndexes = tools.flatMap((tool, index) => {
-		if (!ANTHROPIC_STRICT_TOOL_ALLOWLIST.has(tool.name)) return [];
-		if (tool.strict === false) return [];
-		if (hasAnthropicStrictIncompatibleKeyword(toolWireSchema(tool))) return [];
-		return [index];
-	});
-	let strictToolCount = 0;
-	let strictOptionalParameterCount = 0;
-	let strictUnionParameterCount = 0;
-	for (const index of candidateIndexes) {
-		if (strictToolCount >= MAX_ANTHROPIC_STRICT_TOOLS) break;
-		const strictResult = normalizeAnthropicStrictSchema(plans[index].inputSchema, MAX_ANTHROPIC_STRICT_OPTIONAL_PARAMETERS - strictOptionalParameterCount, MAX_ANTHROPIC_STRICT_UNION_PARAMETERS - strictUnionParameterCount);
-		if (!strictResult) continue;
-		plans[index] = {
-			inputSchema: strictResult.schema,
-			strict: true
-		};
-		strictToolCount++;
-		strictOptionalParameterCount += strictResult.optionalCount;
-		strictUnionParameterCount += strictResult.unionCount;
-	}
-	return plans;
-}
-function convertTools(tools, isOAuthToken, disableStrictTools = false, supportsEagerToolInputStreaming = true, escapeBuiltinToolNames = false, useUmansGatewayWebSearch = false) {
-	if (!tools) return [];
-	const schemaPlans = buildAnthropicToolSchemaPlans(tools, disableStrictTools);
-	return tools.map((tool, index) => {
-		const plan = schemaPlans[index];
-		return {
-			name: encodeAnthropicToolName(tool.name, isOAuthToken, escapeBuiltinToolNames, useUmansGatewayWebSearch),
-			description: tool.description || "",
-			input_schema: plan.inputSchema,
-			...supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {},
-			...plan.strict ? { strict: true } : {},
-			...tool.deferLoading ? { defer_loading: true } : {}
-		};
-	});
-}
-function mapStopReason(reason) {
-	switch (reason) {
-		case "end_turn": return "stop";
-		case "max_tokens": return "length";
-		case "model_context_window_exceeded": return "length";
-		case "tool_use": return "toolUse";
-		case "refusal": return "error";
-		case "pause_turn": return "stop";
-		case "stop_sequence": return "stop";
-		case "sensitive": return "error";
-		default:
-			reportAnthropicEnvelopeAnomaly(`unhandled stop reason: ${reason}`);
-			return "stop";
-	}
-}
-//#endregion
-export { anthropic_exports as t };