@xiaoso/dsh-tool-plus 0.1.5 → 0.1.7-beta.0

package/lib/{anthropic-BL6LFDQS.mjs → anthropic-CTJ3IQVa.mjs}

@@ -1,34 +1,29 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
 import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
-import { P as $env, S as debug, T as warn, _ as parseStreamingJsonThrottled, a as readSseEvents, h as parseJsonWithRepair, q as getInstallId, y as isEnoent } from "./src-BcD0_rQR.mjs";
-import { A as isTransientStreamParseError, D as isFastModeUnsupported, E as isCopilotTransientModelError, F as AnthropicStreamEnvelopeError, M as AnthropicApiError, N as AnthropicConnectionError, O as isGrammarError, P as AnthropicConnectionTimeoutError, a as isTransientStatus, f as getHeadersFromError, i as isProviderRetryableError$1, k as isStreamEnvelopeError, l as finalize, n as StreamTimeoutError, p as getRetryAfterMsFromHeaders, r as ValidationError, s as ProviderResponseError, t as ConfigurationError, u as finalizeErrorMessage, v as AbortError } from "./error-C-f_Wnw4.mjs";
-import { A as NO_STRICT, C as kStreamingPartialJson, R as spillToDescription, S as kStreamingLastParseLen, a as normalizeSystemPrompts, h as clearStreamingPartialJson, k as toolWireSchema, m as transformMessages, o as normalizeToolCallId, s as resolveCacheRetention, w as renderDemotedThinking, y as kStreamingBlockIndex, z as COMBINATOR_KEYS } from "./utils-Cp2Mxf_U.mjs";
-import { n as isRecord } from "./type-guards-B9VVjRDK.mjs";
-import { Ct as withEmptyCompletionRetry, K as getOpenAIPromptCacheKey, _t as isForcedToolChoice, gt as resolveGitHubCopilotBaseUrl, ht as hasCopilotVisionInput, mt as buildCopilotDynamicHeaders, n as getEnvApiKey, t as OUTPUT_FALLBACK_BUFFER, wt as isFoundryEnabled } from "./stream-Bjq8wjfr.mjs";
-import { t as createAbortSourceTracker } from "./abort-Cwwm4Err.mjs";
-import { N as isVertexRawPredictUrl, f as isAnthropicSigningProxyUrl, j as hostMatchesUrl, n as getBundledModel, o as mapEffortToAnthropicAdaptiveEffort, p as isOfficialAnthropicApiUrl, t as calculateCost } from "./models-DRA2c_8U.mjs";
-import { r as isAnthropicOAuthToken } from "./utils-CQHPEQ3W.mjs";
-import { u as parseGitHubCopilotApiKey } from "./github-copilot-B3kQl0g0.mjs";
-import { t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-mBmtAHx0.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-Dh2guZxS.mjs";
-import { a as coworkUserAgent, i as claudeCodeVersion, n as CLAUDE_CODE_MAX_OUTPUT_TOKENS, r as claudeCodeSystemInstruction } from "./anthropic-CDmj476p.mjs";
-import { a as getStreamIdleTimeoutMs, i as getStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout } from "./idle-iterator-CYAxUkSD.mjs";
-import { t as notifyProviderResponse } from "./provider-response-C6vcbQyO.mjs";
-import { t as notifyRawSseEvent } from "./sse-debug-CYdjOC96.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-BwW51vA5.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-CORgGg5a.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-CUPhpw9A.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-B_7qN-bA.mjs";
+import { r as isAnthropicOAuthToken } from "./utils-DeWqNWV8.mjs";
+import { a as mapEffortToAnthropicAdaptiveEffort, n as isAnthropicServerToolHistoryBlock, r as parseAnthropicInputTransformations, t as THINKING_BINDING_CONTROLS_BETA } from "./anthropic-wire-CKuhDwZ1.mjs";
+import { t as createAbortSourceTracker } from "./abort-Caqff3M6.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-DOh1gt_w.mjs";
+import { t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-_XwsL1DF.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ulcDenZD.mjs";
+import { a as claudeCodeUserAgent, i as claudeCodeSystemInstruction, n as CLAUDE_CODE_MAX_OUTPUT_TOKENS, o as claudeCodeVersion, r as claudeCodeSdkVersion } from "./anthropic-CXfWlp-x.mjs";
+import { n as isVertexRawPredictUrl, t as hostMatchesUrl } from "./hosts-00rjRzUD.mjs";
+import { a as isOfficialAnthropicApiUrl, i as isAnthropicSigningProxyUrl } from "./collapse-DOR8sOGf.mjs";
+import { a as getStreamIdleTimeoutMs, i as getStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout } from "./idle-iterator-DlUkEfzW.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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/anthropic-wire.ts
-/** True when a block is complete Anthropic server-tool history omp can replay. */
-function isAnthropicServerToolHistoryBlock(block) {
-	if (block.type === "server_tool_use") return (block.name === "web_search" || block.name === "tool_search_tool_regex" || block.name === "tool_search_tool_bm25") && typeof block.id === "string" && block.id.length > 0;
-	if (block.type === "web_search_tool_result" || block.type === "tool_search_tool_result") return typeof block.tool_use_id === "string" && block.tool_use_id.length > 0 && Object.hasOwn(block, "content");
-	return false;
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/sdk-stream-timeout.ts
+//#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.
@@ -72,7 +67,7 @@ function createSdkStreamRequestOptions(signal, streamFirstEventTimeoutMs) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/anthropic-client.ts
+//#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.
 *
@@ -236,7 +231,7 @@ var AnthropicMessagesClient = class {
 		callerSignal?.addEventListener("abort", onAbort, { once: true });
 		try {
 			return await fetchFn(url, {
-				...this.#options.fetchOptions ?? {},
+				...this.#options.fetchOptions,
 				method: "POST",
 				headers,
 				body,
@@ -260,7 +255,7 @@ var AnthropicMessagesClient = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/anthropic.ts
+//#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,
@@ -269,17 +264,19 @@ var anthropic_exports = /* @__PURE__ */ __exportAll({
 	buildAnthropicHeaders: () => buildAnthropicHeaders,
 	buildAnthropicSystemBlocks: () => buildAnthropicSystemBlocks,
 	buildBetaHeader: () => buildBetaHeader,
+	claudeCodeHeaders: () => claudeCodeHeaders,
+	claudeCodeSdkVersion: () => claudeCodeSdkVersion,
 	claudeCodeSystemInstruction: () => claudeCodeSystemInstruction,
+	claudeCodeUserAgent: () => claudeCodeUserAgent,
 	claudeCodeVersion: () => claudeCodeVersion,
 	claudeToolPrefix: () => "_",
 	convertAnthropicMessages: () => convertAnthropicMessages,
-	coworkHeaders: () => coworkHeaders,
-	coworkUserAgent: () => coworkUserAgent,
 	deriveClaudeDeviceId: () => deriveClaudeDeviceId,
 	isClaudeCloakingUserId: () => isClaudeCloakingUserId,
 	isInvalidThinkingSignatureError: () => isInvalidThinkingSignatureError,
-	isProviderRetryableError: () => isProviderRetryableError,
+	isThinkingPrefixBindingError: () => isThinkingPrefixBindingError,
 	mapStainlessArch: () => mapStainlessArch,
+	mapStainlessOs: () => mapStainlessOs,
 	maybeAddReplayUnsignedThinkingHint: () => maybeAddReplayUnsignedThinkingHint,
 	normalizeAnthropicBaseUrl: () => normalizeAnthropicBaseUrl,
 	normalizeAnthropicToolSchema: () => normalizeAnthropicToolSchema,
@@ -319,26 +316,31 @@ 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 coworkUtilityBetaDefaults = [
+const claudeCodeUtilityBetaDefaults = [
+	oauthAuthBeta,
 	"interleaved-thinking-2025-05-14",
 	thinkingTokenCountBeta,
 	contextManagementBeta,
 	"prompt-caching-scope-2026-01-05",
 	structuredOutputsBeta
 ];
-const coworkAgentBetaDefaults = [
+const claudeCodeAgentBetaDefaults = [
 	"claude-code-20250219",
+	oauthAuthBeta,
 	"interleaved-thinking-2025-05-14",
 	thinkingTokenCountBeta,
 	contextManagementBeta,
 	"prompt-caching-scope-2026-01-05",
-	midConversationSystemBeta,
-	"advanced-tool-use-2025-11-20"
+	midConversationSystemBeta
 ];
 const extendedCacheTtlBeta = "extended-cache-ttl-2025-04-11";
 const fineGrainedToolStreamingBeta = "fine-grained-tool-streaming-2025-05-14";
@@ -347,11 +349,20 @@ 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 buildCoworkBetas(agentRequest, thinkingRequest, disableStrictTools = false) {
-	if (!agentRequest && !disableStrictTools) return coworkUtilityBetaDefaults;
+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 ? coworkAgentBetaDefaults : coworkUtilityBetaDefaults) {
+	for (const beta of agentRequest ? claudeCodeAgentBetaDefaults : claudeCodeUtilityBetaDefaults) {
 		if (disableStrictTools && beta === structuredOutputsBeta) continue;
+		if (!supportsContextManagement && beta === contextManagementBeta) continue;
 		betas.push(beta);
 	}
 	if (!agentRequest) return betas;
@@ -359,11 +370,6 @@ function buildCoworkBetas(agentRequest, thinkingRequest, disableStrictTools = fa
 	betas.push(fallbackCreditBeta);
 	return betas;
 }
-function getHeaderCaseInsensitive(headers, headerName) {
-	if (!headers) return void 0;
-	const normalizedName = headerName.toLowerCase();
-	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === normalizedName) return value;
-}
 function isClaudeCodeClientUserAgent(userAgent) {
 	if (!userAgent) return false;
 	return userAgent.toLowerCase().startsWith("claude-cli");
@@ -383,7 +389,10 @@ function buildAnthropicHeaders(options) {
 	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.coworkBetas ?? (oauthToken ? buildCoworkBetas(true, true) : []), extraBetas);
+	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;
@@ -419,20 +428,19 @@ function buildAnthropicHeaders(options) {
 		"cf-aig-authorization": `Bearer ${options.apiKey}`
 	};
 	if (oauthToken) {
-		const userAgent = isClaudeCodeClientUserAgent(incomingUserAgent) ? incomingUserAgent : coworkUserAgent;
+		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 } : {},
-			...coworkHeaders,
+			...claudeCodeHeaders,
 			...betaHeader ? { "anthropic-beta": betaHeader } : {},
 			"anthropic-dangerous-direct-browser-access": "true",
 			"anthropic-version": "2023-06-01",
 			Authorization: `Bearer ${options.apiKey}`,
 			"x-app": "cli",
-			"x-client-request-id": nodeCrypto.randomUUID(),
 			Connection: "keep-alive",
 			"Accept-Encoding": "gzip, deflate, br, zstd",
 			...incomingApiKey ? { "X-Api-Key": incomingApiKey } : {}
@@ -468,15 +476,31 @@ function cloneAnthropicCacheControl(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;
@@ -496,7 +520,11 @@ function getAnthropicProviderSessionState(providerSessionState, baseUrl, modelId
 	if (!providerSessionState) return void 0;
 	const key = anthropicProviderSessionStateKey(baseUrl, modelId);
 	const existing = providerSessionState.get(key);
-	if (existing) return existing;
+	if (existing) {
+		existing.prefixDroppedThinkingBlocks ??= /* @__PURE__ */ new Set();
+		existing.controlStates ??= /* @__PURE__ */ new Map();
+		return existing;
+	}
 	const created = createAnthropicProviderSessionState();
 	providerSessionState.set(key, created);
 	return created;
@@ -523,6 +551,18 @@ function getCacheControl(model, cacheRetention) {
 		}
 	};
 }
+/** 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":
@@ -535,19 +575,19 @@ function mapStainlessArch(arch) {
 		default: return `other::${arch.toLowerCase()}`;
 	}
 }
-/** Static headers emitted by Cowork's Linux Claude runtime. */
-const coworkHeaders = {
+/** Static headers emitted by Claude Code's CLI runtime. */
+const claudeCodeHeaders = {
 	"X-Stainless-Arch": mapStainlessArch(process.arch),
 	"X-Stainless-Lang": "js",
-	"X-Stainless-OS": "Linux",
-	"X-Stainless-Package-Version": "0.94.0",
+	"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(coworkHeaders),
+	...Object.keys(claudeCodeHeaders),
 	"Accept",
 	"Accept-Encoding",
 	"Connection",
@@ -564,7 +604,7 @@ const enforcedHeaderKeys = new Set([
 	"cf-aig-authorization"
 ].map((key) => key.toLowerCase()));
 const overridableAnthropicHeaderKeys = new Set([
-	...Object.keys(coworkHeaders),
+	...Object.keys(claudeCodeHeaders),
 	"anthropic-beta",
 	"User-Agent",
 	"x-app"
@@ -577,7 +617,7 @@ function createClaudeBillingHeader(firstUserMessageText) {
 		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=claude-desktop; ${CCH_PLACEHOLDER_STR};`;
+	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";
@@ -816,7 +856,7 @@ async function resizeAnthropicManyImageBlock(block) {
 async function resizeAnthropicManyImageContent(content, state, limit) {
 	let changed = false;
 	const next = await Promise.all(content.map(async (block) => {
-		if (block.type !== "image") return 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));
@@ -896,22 +936,34 @@ function convertContentBlocks(content, supportsImages = true) {
 			});
 			continue;
 		}
-		const mediaType = normalizeAnthropicImageMediaType(block.mimeType);
-		if (!mediaType) {
-			blocks.push({
-				type: "text",
-				text: `[unsupported image: ${block.mimeType}]`
-			});
-			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: {
-				type: "base64",
-				media_type: mediaType,
-				data: block.data
-			}
+			source
 		});
 	}
 	if (!supportsImages) return blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n").toWellFormed();
@@ -921,7 +973,7 @@ function convertContentBlocks(content, supportsImages = true) {
 	});
 	return blocks;
 }
-const COWORK_TLS_CIPHERS = tls.DEFAULT_CIPHERS;
+const CLAUDE_CODE_TLS_CIPHERS = tls.DEFAULT_CIPHERS;
 const foundryTlsOptionsCache = /* @__PURE__ */ new Map();
 function foundryTlsCacheKeyComponent(value) {
 	if (!value) return null;
@@ -1025,7 +1077,7 @@ function resolveFoundryTlsOptions(model) {
 	foundryTlsOptionsCache.set(cacheKey, resolved);
 	return resolved;
 }
-function buildCoworkTlsFetchOptions(model, baseUrl) {
+function buildClaudeCodeTlsFetchOptions(model, baseUrl) {
 	if (model.provider !== "anthropic") return void 0;
 	if (!baseUrl) return void 0;
 	let serverName;
@@ -1039,8 +1091,8 @@ function buildCoworkTlsFetchOptions(model, baseUrl) {
 	return { tls: {
 		rejectUnauthorized: true,
 		serverName,
-		...COWORK_TLS_CIPHERS ? { ciphers: COWORK_TLS_CIPHERS } : {},
-		...foundryTlsOptions ?? {}
+		...CLAUDE_CODE_TLS_CIPHERS ? { ciphers: CLAUDE_CODE_TLS_CIPHERS } : {},
+		...foundryTlsOptions
 	} };
 }
 function mergeHeaders(...headerSources) {
@@ -1155,12 +1207,6 @@ async function* observeDecodedAnthropicSdkEvents(events, observer) {
 }
 const PROVIDER_MAX_RETRIES = 10;
 /**
-* Flat delay between attempts when Copilot 400s a model its own `/models`
-* catalog advertises. Part of the fleet carries the model and part doesn't, so
-* the retry is a reroll rather than a wait for capacity to free up.
-*/
-const COPILOT_MODEL_FLAP_RETRY_DELAY_MS = 400;
-/**
 * 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
@@ -1184,18 +1230,6 @@ function shouldIgnoreAnthropicPreambleEvent(eventType) {
 	if (eventType === "ping") return true;
 	return !ANTHROPIC_MESSAGE_EVENTS.has(eventType);
 }
-/**
-* Whether an Anthropic (or Copilot-over-Anthropic) stream error should be
-* retried. The classification lives in {@link AIError.isProviderRetryableError};
-* this wrapper injects the Copilot-specific model-availability transient check,
-* which the error module must not import directly.
-*/
-function isProviderRetryableError(error, provider) {
-	return isProviderRetryableError$1(error, {
-		provider,
-		isProviderTransient: provider === "github-copilot" ? (err) => isCopilotTransientModelError(err) : void 0
-	});
-}
 const THINKING_ENVELOPE_OPEN = "<thinking>";
 const THINKING_ENVELOPE_CLOSE = "</thinking>";
 function unwrapAnthropicThinkingEnvelope(text) {
@@ -1320,7 +1354,7 @@ function resolveIterationModel(requestModel, iterationModelId) {
 	}
 	return requestModel;
 }
-function calculateFallbackTurnCost(requestModel, usage, source) {
+function calculateFallbackTurnCost(requestModel, usage, source, timestamp) {
 	const iterations = source.iterations ?? [];
 	if (iterations.length === 0) return false;
 	const cost = {
@@ -1350,7 +1384,7 @@ function calculateFallbackTurnCost(requestModel, usage, source) {
 		iterationUsage.output = outputTokens;
 		iterationUsage.cacheWrite = cacheWriteTokens;
 		iterationUsage.totalTokens = iterationUsage.input + iterationUsage.output + iterationUsage.cacheRead + iterationUsage.cacheWrite;
-		calculateCost(resolveIterationModel(requestModel, iteration.model), iterationUsage);
+		calculateCost(resolveIterationModel(requestModel, iteration.model), iterationUsage, timestamp);
 		cost.input += iterationUsage.cost.input;
 		cost.output += iterationUsage.cost.output;
 		cost.cacheRead += iterationUsage.cost.cacheRead;
@@ -1363,24 +1397,112 @@ function calculateFallbackTurnCost(requestModel, usage, source) {
 	return true;
 }
 /**
-* Detects the Anthropic `400 Invalid `signature` in `thinking` block` failure
-* a signing proxy returns when a stripped/unsigned prior thinking block is
-* replayed as `signature: ""`. Exported for the compat tests.
+* 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);
+	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 Anthropic's `Invalid signature in thinking
-* block` 400 when the model looks like an unmarked custom signing proxy
+* 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)) return 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}`;
@@ -1410,9 +1532,10 @@ const streamAnthropicOnce = (model, context, options) => {
 				hasImages: hasCopilotVisionInput(context.messages),
 				premiumMultiplier: model.premiumMultiplier,
 				headers: {
-					...model.headers ?? {},
-					...options?.headers ?? {}
+					...model.headers,
+					...options?.headers
 				},
+				integrationId: resolveCopilotRequestIdentity(options?.headers),
 				initiatorOverride: options?.initiatorOverride
 			}) : void 0;
 			if (copilotDynamicHeaders?.premiumRequests !== void 0) output.usage.premiumRequests = copilotDynamicHeaders.premiumRequests;
@@ -1423,10 +1546,14 @@ const streamAnthropicOnce = (model, context, options) => {
 			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.provider === "google-vertex" && fallbacks?.some((entry) => entry.output_config?.effort !== void 0)) fallbacks = fallbacks.map((entry) => {
+			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 {
@@ -1445,9 +1572,11 @@ const streamAnthropicOnce = (model, context, options) => {
 				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.provider !== "google-vertex" && (options?.thinkingEnabled && options.effort !== "adaptive" || sendsAdaptiveEffortPin) && !extraBetas.includes(effortBeta)) extraBetas.push(effortBeta);
-				if (model.compat.supportsMidConversationSystem && !extraBetas.includes(midConversationSystemBeta)) extraBetas.push(midConversationSystemBeta);
-				if (model.reasoning && options?.thinkingEnabled && model.provider !== "github-copilot" && model.provider !== "google-vertex" && model.provider !== "opencode-zen" && !extraBetas.includes(contextManagementBeta)) extraBetas.push(contextManagementBeta);
+				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);
@@ -1471,7 +1600,7 @@ const streamAnthropicOnce = (model, context, options) => {
 					thinkingDisplay: options?.thinkingDisplay,
 					fetch: options?.fetch,
 					maxRetryDelayMs: options?.maxRetryDelayMs,
-					claudeCodeSessionId: options?.sessionId ?? extractClaudeMetadataSessionId(options?.metadata?.user_id),
+					sessionId: options?.sessionId ?? extractClaudeMetadataSessionId(options?.metadata?.user_id) ?? options?.promptCacheKey,
 					disableStrictTools
 				});
 				client = created.client;
@@ -1484,6 +1613,10 @@ const streamAnthropicOnce = (model, context, options) => {
 					useUmansGatewayWebSearch: umansGatewayWebSearchHeader !== void 0,
 					forceDemoteUnsignedThinking,
 					supportsEagerToolInputStreaming,
+					prefixMismatchBehavior,
+					dropAllThinking,
+					droppedThinkingBlocks: providerSessionState?.prefixDroppedThinkingBlocks,
+					providerSessionState,
 					fallbacks
 				});
 				if (disableStrictTools) dropAnthropicStrictTools(nextParams);
@@ -1502,6 +1635,7 @@ const streamAnthropicOnce = (model, context, options) => {
 				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;
@@ -1533,13 +1667,14 @@ const streamAnthropicOnce = (model, context, options) => {
 				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);
+				calculateCost(model, output.usage, output.timestamp);
 				output.duration = performance.now() - startTime;
 				stream.push({
 					type: "start",
@@ -1618,10 +1753,14 @@ const streamAnthropicOnce = (model, context, options) => {
 			while (true) {
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
 				const { requestSignal } = activeAbortTracker;
-				const injectedClientEffortHeaders = options?.client !== void 0 && params.output_config?.effort !== void 0 ? mergeAnthropicBetaHeader(mergedCallerHeaders, effortBeta) : void 0;
-				const perRequestHeaders = umansGatewayWebSearchHeader || injectedClientEffortHeaders ? {
+				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,
-					...injectedClientEffortHeaders
+					...injectedClientBetaHeaders
 				} : void 0;
 				const requestOptions = {
 					...createSdkStreamRequestOptions(requestSignal, requestTimeoutMs),
@@ -1693,6 +1832,7 @@ const streamAnthropicOnce = (model, context, options) => {
 							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);
@@ -1704,8 +1844,8 @@ const streamAnthropicOnce = (model, context, options) => {
 								if (serverSideFallback) {
 									const served = fallbackServedModelFromUsage(startUsage);
 									if (served) output.model = served;
-									if (!calculateFallbackTurnCost(model, output.usage, startUsage)) calculateCost(model, output.usage);
-								} else calculateCost(model, output.usage);
+									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;
 						}
@@ -1952,6 +2092,7 @@ const streamAnthropicOnce = (model, context, options) => {
 								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);
@@ -1978,12 +2119,13 @@ const streamAnthropicOnce = (model, context, options) => {
 								if (serverSideFallback) {
 									const served = fallbackServedModelFromUsage(deltaUsage);
 									if (served) output.model = served;
-									if (!calculateFallbackTurnCost(model, output.usage, deltaUsage)) calculateCost(model, output.usage);
-								} else calculateCost(model, output.usage);
+									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();
@@ -2027,12 +2169,35 @@ const streamAnthropicOnce = (model, context, options) => {
 						firstTokenTime = void 0;
 						continue;
 					}
-					if (!forceDemoteUnsignedThinking && firstTokenTime === void 0 && !streamedReplayUnsafeContent && isInvalidThinkingSignatureError(streamFailure instanceof Error ? streamFailure.message : String(streamFailure))) {
-						warn("anthropic: signing proxy detected (Invalid signature in thinking block), demoting unsigned thinking and retrying", {
+					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: streamFailure instanceof Error ? streamFailure.message : String(streamFailure)
+							error: streamFailureMessage
 						});
 						if (providerSessionState) providerSessionState.replayUnsignedThinkingDisabled = true;
 						forceDemoteUnsignedThinking = true;
@@ -2070,10 +2235,10 @@ const streamAnthropicOnce = (model, context, options) => {
 					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, model.provider);
+					const canRetryProviderFailure = !isLocalIdleTimeout && firstTokenTime === void 0 && !streamedReplayUnsafeContent && isProviderRetryableError(streamFailure);
 					if (activeAbortTracker.wasCallerAbort() || providerRetryAttempt >= PROVIDER_MAX_RETRIES || !canRetryTransientEnvelopeFailure && !canRetryProviderFailure) throw streamFailure;
 					providerRetryAttempt++;
-					const backoffDelayMs = isCopilotTransientModelError(streamFailure) ? COPILOT_MODEL_FLAP_RETRY_DELAY_MS : calculateAnthropicRetryDelayMs(providerRetryAttempt - 1);
+					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;
@@ -2126,15 +2291,12 @@ const streamAnthropicOnce = (model, context, options) => {
 	return stream;
 };
 /**
-* Public entry: wrap the single-attempt streamer with bounded empty-completion
-* retries (a benign terminal stop carrying no content/usage would otherwise
-* stall the agent loop). The inner attempt keeps its own provider-failure retry
-* loop; this layer only re-issues a fresh request on an empty success. Shared
-* with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+* 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) => withEmptyCompletionRetry(model, context, options, streamAnthropicOnce);
+const streamAnthropic = (model, context, options) => withReplaySafeStreamRetry(model, context, options, streamAnthropicOnce, { retryEmptyCompletion: true });
 function buildAnthropicSystemBlocks(systemPrompt, options = {}) {
-	const { includeClaudeCodeInstruction = false, extraInstructions = [], firstUserMessageText } = 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));
@@ -2144,7 +2306,8 @@ function buildAnthropicSystemBlocks(systemPrompt, options = {}) {
 			text: createClaudeBillingHeader(firstUserMessageText ?? "")
 		}, {
 			type: "text",
-			text: claudeCodeSystemInstruction
+			text: claudeCodeSystemInstruction,
+			cache_control: cacheControl ? cloneAnthropicCacheControl(cacheControl) : { type: "ephemeral" }
 		}];
 		for (const instruction of trimmedInstructions) blocks.push({
 			type: "text",
@@ -2172,7 +2335,7 @@ function normalizeExtraBetas(betas) {
 	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, claudeCodeSessionId, disableStrictTools: disableStrictToolsOverride } = 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);
@@ -2182,7 +2345,7 @@ function buildAnthropicClientOptions(args) {
 	const needsFineGrainedToolStreamingBeta = hasTools && isOfficialAnthropicApiUrl(baseUrl) && !supportsEagerToolInputStreaming;
 	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model, baseUrl);
 	const fetchOptions = {
-		...buildCoworkTlsFetchOptions(model, baseUrl) ?? {},
+		...buildClaudeCodeTlsFetchOptions(model, baseUrl),
 		timeout: false
 	};
 	const baseFetch = args.fetch ?? fetch;
@@ -2190,6 +2353,19 @@ function buildAnthropicClientOptions(args) {
 	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,
@@ -2197,15 +2373,8 @@ function buildAnthropicClientOptions(args) {
 			baseURL: baseUrl,
 			maxRetries: 5,
 			maxRetryDelayMs,
-			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),
-			fetch: cchFetch,
+			defaultHeaders,
+			fetch: wrapFetchForCopilotFallback(cchFetch, true, resolveCopilotRequestIdentity(headers)),
 			fetchOptions
 		};
 	}
@@ -2221,8 +2390,18 @@ function buildAnthropicClientOptions(args) {
 		modelHeaders: mergeHeaders(model.headers, foundryCustomHeaders, getUmansWebSearchHeader(model, mergeHeaders(model.headers, headers)), headers, dynamicHeaders),
 		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
 		allowAnthropicHeaderOverrides: model.compat.allowAnthropicHeaderOverrides,
-		claudeCodeSessionId,
-		coworkBetas: oauthToken ? buildCoworkBetas(hasTools || thinkingEnabled, thinkingEnabled, disableStrictTools) : []
+		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,
@@ -2279,7 +2458,7 @@ function disableThinkingIfToolChoiceForced(params, model) {
 	if (toolChoice.type !== "any" && toolChoice.type !== "tool") return;
 	delete params.thinking;
 	delete params.context_management;
-	if (isAdaptiveOnlyThinking(model) && model.provider !== "google-vertex") {
+	if (isAdaptiveOnlyThinking(model) && model.compat.supportsOutputEffort) {
 		const outputConfig = params.output_config ?? {};
 		outputConfig.effort = "low";
 		params.output_config = outputConfig;
@@ -2306,7 +2485,7 @@ function ensureMaxTokensForThinking(params, maxAllowedTokens) {
 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") continue;
+		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,
@@ -2321,10 +2500,11 @@ function applyPromptCaching(params, cacheControl) {
 	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;
-	const start = Math.max(0, messageEnd - 1);
-	for (let index = messageEnd; index >= start; index--) {
+	let eligibleMessages = 0;
+	for (let index = messageEnd; index >= 0 && eligibleMessages < 2; index--) {
 		const message = params.messages[index];
-		if (!message) continue;
+		if (!message || message.clear_at === "next_user_message") continue;
+		eligibleMessages++;
 		if (typeof message.content === "string") message.content = [{
 			type: "text",
 			text: message.content,
@@ -2333,6 +2513,46 @@ function applyPromptCaching(params, 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;
@@ -2369,8 +2589,227 @@ function extractClaudeCodeFirstUserMessageText(messages) {
 	}
 	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, fallbacks = options?.fallbacks } = buildOptions;
+	const { disableStrictTools, useUmansGatewayWebSearch, forceDemoteUnsignedThinking, supportsEagerToolInputStreaming, prefixMismatchBehavior, dropAllThinking, droppedThinkingBlocks, providerSessionState, fallbacks = options?.fallbacks } = buildOptions;
 	const effectiveModel = forceDemoteUnsignedThinking && model.compat.replayUnsignedThinking ? {
 		...model,
 		compat: {
@@ -2379,14 +2818,15 @@ function buildParams(model, context, isOAuthToken, options, buildOptions) {
 		}
 	} : model;
 	const { cacheControl } = getCacheControl(model, options?.cacheRetention);
-	const shouldInjectClaudeCodeInstruction = isOAuthToken && !model.id.startsWith("claude-3-5-haiku");
+	const shouldInjectClaudeCodeInstruction = isOAuthToken && model.compat.injectClaudeCodeInstruction !== false;
 	const firstUserMessageText = shouldInjectClaudeCodeInstruction ? extractClaudeCodeFirstUserMessageText(context.messages) : "";
-	const systemBlocks = buildAnthropicSystemBlocks(context.systemPrompt, {
+	let systemBlocks = buildAnthropicSystemBlocks(context.systemPrompt, {
 		includeClaudeCodeInstruction: shouldInjectClaudeCodeInstruction,
-		firstUserMessageText
+		firstUserMessageText,
+		cacheControl
 	});
 	let tools;
-	if (context.tools) tools = convertTools(context.tools, isOAuthToken, disableStrictTools || model.provider === "github-copilot", supportsEagerToolInputStreaming, model.compat.escapeBuiltinToolNames, useUmansGatewayWebSearch);
+	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);
@@ -2417,19 +2857,36 @@ function buildParams(model, context, isOAuthToken, options, buildOptions) {
 			else thinking = { type: "disabled" };
 		}
 	}
-	const contextManagement = !options?.client && model.provider !== "github-copilot" && model.provider !== "google-vertex" && model.provider !== "opencode-zen" && (thinking?.type === "adaptive" || thinking?.type === "enabled") ? { edits: [{
+	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 (outputConfigEffort && model.provider !== "google-vertex") outputConfigEntries.effort = outputConfigEffort;
+	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: convertAnthropicMessages(context.messages, effectiveModel, isOAuthToken, { serverSideFallbackEnabled: !!fallbacks?.length }),
+		messages: wireMessages,
 		...systemBlocks && { system: systemBlocks },
 		...tools !== void 0 && { tools },
 		...metadata && { metadata },
@@ -2438,6 +2895,7 @@ function buildParams(model, context, isOAuthToken, options, buildOptions) {
 		...contextManagement && { context_management: contextManagement },
 		...outputConfig && { output_config: outputConfig },
 		...fallbacks?.length ? { fallbacks } : {},
+		...vertexControlBetas.length > 0 ? { anthropic_beta: vertexControlBetas } : {},
 		stream: true
 	};
 	const thinkingType = params.thinking?.type;
@@ -2489,6 +2947,7 @@ function buildToolResultBlock(model, msg, hoistedImages) {
 		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",
@@ -2539,28 +2998,50 @@ function toWellFormedDeep(value) {
 * that don't send the beta.
 */
 function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
-	const developerParamIndices = [];
+	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") {
-			if (!msg.content) continue;
+			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) continue;
-				content = msg.content.toWellFormed();
+				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) continue;
-					content = contentBlocks;
+					if (contentBlocks.trim().length === 0) {
+						if (!hasProviderControls) continue;
+						content = [];
+					} else content = contentBlocks;
 				} else {
-					if (contentBlocks.length === 0) continue;
+					if (contentBlocks.length === 0 && !hasProviderControls) continue;
 					content = contentBlocks;
 				}
 			}
-			if (msg.role === "developer") developerParamIndices.push(params.length);
+			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
@@ -2575,6 +3056,7 @@ function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
 					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;
@@ -2608,6 +3090,7 @@ function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
 					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",
@@ -2630,7 +3113,7 @@ function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
 			let sawToolUse = false;
 			let needsPartition = false;
 			for (const block of blocks) if (block.type === "tool_use") sawToolUse = true;
-			else if (sawToolUse) {
+			else if (sawToolUse && block.type !== "thinking" && block.type !== "redacted_thinking") {
 				needsPartition = true;
 				break;
 			}
@@ -2668,15 +3151,40 @@ function convertAnthropicMessages(messages, model, isOAuthToken, opts) {
 			});
 		}
 	}
-	if (developerParamIndices.length > 0 && model.compat.supportsMidConversationSystem) for (const idx of developerParamIndices) {
+	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 textOnly = typeof content === "string" || content.every((block) => block.type === "text");
-		if (followsUser && lastOrBeforeAssistant && textOnly) params[idx] = {
+		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
+			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, {
@@ -3092,7 +3600,8 @@ function convertTools(tools, isOAuthToken, disableStrictTools = false, supportsE
 			description: tool.description || "",
 			input_schema: plan.inputSchema,
 			...supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {},
-			...plan.strict ? { strict: true } : {}
+			...plan.strict ? { strict: true } : {},
+			...tool.deferLoading ? { defer_loading: true } : {}
 		};
 	});
 }