@openclaw/ai 2026.9.2 → 2026.9.3

package/dist/{anthropic-compaction-replay-DB2FGLQc.mjs → anthropic-stream-reducer-B_yo_7pf.mjs}

@@ -1,12 +1,20 @@
-import { d as resolveClaudeModelIdentity, m as resolveClaudeOpus5ModelIdentity, u as resolveClaudeFable5ModelIdentity } from "./src-2qBGKg8O.mjs";
-import { l as normalizeNullableString, o as isRecord, u as normalizeOptionalLowercaseString } from "./utf16-slice-qz3nsy87.mjs";
-import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
-import { a as asNonNegativeFiniteNumber, n as estimateBase64DecodedBytes } from "./base64-CEFBpSkN.mjs";
+import { _ as supportsClaudeAdaptiveThinking, b as supportsClaudeNativeXhighEffort, d as resolveClaudeModelIdentity, m as resolveClaudeOpus5ModelIdentity, u as resolveClaudeFable5ModelIdentity } from "./src-B2Q_6G8V.mjs";
+import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
+import { i as normalizeOptionalLowercaseString, r as normalizeNullableString } from "./string-coerce-fsri9iCu.mjs";
+import { r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-Bb-v9meu.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, n as getAiTransportHost, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking } from "./host-CWuF-sS3.mjs";
+import { a as asRecord, o as isRecord, r as asOptionalObjectRecord, s as readStringField } from "./record-coerce-DwRYMj3t.mjs";
+import { i as asNonNegativeFiniteNumber, n as estimateBase64DecodedBytes } from "./base64-D-su8YVo.mjs";
+import { a as parsePositiveInteger } from "./transport-utils-CCooe-cr.mjs";
+import { a as resolveProviderRequestCapabilities, i as resolveProviderEndpoint } from "./host-policy-CAopLRKA.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, u as splitSystemPromptCacheBoundary } from "./simple-options-BjHCCh4v.mjs";
-import { a as resolveProviderEndpoint, o as resolveProviderRequestCapabilities, t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-mJhXDcyz.mjs";
-import { s as parsePositiveInteger } from "./transport-utils-7il795_9.mjs";
+import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, u as splitSystemPromptCacheBoundary } from "./simple-options-tcKOqnpF.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-ClptDdAO.mjs";
+import { _ as transportAbortError, b as parseJsonObjectPreservingUnsafeIntegers, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, n as coerceTransportToolCallArguments, s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-Cu3ZPhNW.mjs";
 import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-BuSUaAk5.mjs";
+import { i as tagPendingCommentaryText } from "./assistant-text-phase-C20rxWwP.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-Dw_hnxsA.mjs";
+import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 //#region packages/ai/src/providers/anthropic-auth-headers.ts
 /** Inspect resolved credential shape for auth routing without exposing its value. */
 function isAnthropicOAuthApiKey(apiKey) {
@@ -89,6 +97,48 @@ function resolveAnthropicEphemeralCacheControl(baseUrl, cacheRetention) {
 		...ttl ? { ttl } : {}
 	};
 }
+function resolveAnthropicCacheOptions(model, cacheRetention) {
+	const supportsLongCacheRetention = model.compat?.supportsLongCacheRetention ?? model.provider !== "fireworks";
+	const cacheControl = resolveAnthropicEphemeralCacheControl(model.baseUrl?.trim() || process.env.ANTHROPIC_BASE_URL?.trim() || "https://api.anthropic.com", cacheRetention);
+	return {
+		cacheControl: cacheControl && !supportsLongCacheRetention ? { type: "ephemeral" } : cacheControl,
+		supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? model.provider !== "fireworks"
+	};
+}
+function buildAnthropicSystemBlocks(systemPrompt, isOAuthToken, cacheControl) {
+	const blocks = systemPrompt ? [{
+		type: "text",
+		text: sanitizeSurrogates(systemPrompt)
+	}] : [];
+	if (cacheControl) applyAnthropicCacheControlToSystem(blocks, cacheControl);
+	else stripAnthropicSystemPromptBoundary(blocks);
+	if (systemPrompt && blocks.length === 0) blocks.push({
+		type: "text",
+		text: ""
+	});
+	if (isOAuthToken) {
+		const identityCacheControl = blocks.some((block) => block.cache_control) ? void 0 : cacheControl;
+		blocks.unshift({
+			type: "text",
+			text: ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK
+		}, {
+			type: "text",
+			text: "You are Claude Code, Anthropic's official CLI for Claude.",
+			...identityCacheControl ? { cache_control: identityCacheControl } : {}
+		});
+	}
+	return blocks.length > 0 ? blocks : void 0;
+}
+/** Allocate tool and history checkpoints around the prepared stable system blocks. */
+function applyAnthropicRequestCacheControl(payload, cacheControl, supportsCacheControlOnTools, cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set()) {
+	if (!cacheControl) return;
+	if (supportsCacheControlOnTools && Array.isArray(payload.tools)) {
+		const lastTool = payload.tools.at(-1);
+		if (isRecord(lastTool)) lastTool.cache_control = cacheControl;
+	}
+	const usedMarkers = countAnthropicCacheControlMarkers(payload.system) + countAnthropicCacheControlMarkers(payload.tools);
+	applyAnthropicCacheControlToMessages(payload.messages, cacheControl, ANTHROPIC_CACHE_CONTROL_LIMIT - usedMarkers, cacheBreakpointOptOutMessageIndexes);
+}
 function applyAnthropicCacheControlToSystem(system, cacheControl) {
 	if (!Array.isArray(system)) return;
 	const normalizedBlocks = [];
@@ -286,9 +336,7 @@ function applyAnthropicPayloadPolicyToParams(payloadObj, policy, cacheBreakpoint
 	if (policy.cacheControl) applyAnthropicCacheControlToSystem(payloadObj.system, policy.cacheControl);
 	else stripAnthropicSystemPromptBoundary(payloadObj.system);
 	applyAnthropicContextManagementEdits(payloadObj, policy);
-	if (!policy.cacheControl) return;
-	const usedMarkers = countAnthropicCacheControlMarkers(payloadObj.system) + countAnthropicCacheControlMarkers(payloadObj.tools);
-	applyAnthropicCacheControlToMessages(payloadObj.messages, policy.cacheControl, ANTHROPIC_CACHE_CONTROL_LIMIT - usedMarkers, cacheBreakpointOptOutMessageIndexes);
+	applyAnthropicRequestCacheControl(payloadObj, policy.cacheControl, false, cacheBreakpointOptOutMessageIndexes);
 }
 /** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
 function applyAnthropicEphemeralCacheControlMarkers(payloadObj, cacheControl = { type: "ephemeral" }) {
@@ -322,70 +370,6 @@ function applyAnthropicEphemeralCacheControlMarkers(payloadObj, cacheControl = {
 	}
 }
 //#endregion
-//#region packages/ai/src/internal/anthropic-inline-images.ts
-const ANTHROPIC_IMAGE_MEDIA_TYPE_SET = /* @__PURE__ */ new Set([
-	"image/jpeg",
-	"image/png",
-	"image/gif",
-	"image/webp"
-]);
-const ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES = 67108864;
-function createAnthropicInlineImageBudget() {
-	return { totalBytes: 0 };
-}
-function resolveAnthropicImageMediaType(value) {
-	if (ANTHROPIC_IMAGE_MEDIA_TYPE_SET.has(value)) return value;
-	throw new Error(`Unsupported Anthropic image media type after normalization: ${value}`);
-}
-async function normalizeAnthropicInlineContent(content, budget) {
-	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text");
-	const inputBytes = content.reduce((total, block) => block.type === "image" ? total + estimateBase64DecodedBytes(block.data) : total, 0);
-	if (budget.totalBytes + inputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
-	const normalized = [];
-	for (const block of content) {
-		if (block.type !== "image") {
-			normalized.push(block);
-			continue;
-		}
-		const normalizedBlocks = await getAiTransportHost().normalizeAnthropicInlineContentBlocks([block]);
-		const outputBytes = normalizedBlocks.reduce((total, normalizedBlock) => normalizedBlock.type === "image" ? total + estimateBase64DecodedBytes(normalizedBlock.data) : total, 0);
-		if (budget.totalBytes + outputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
-		budget.totalBytes += outputBytes;
-		normalized.push(...normalizedBlocks);
-	}
-	return normalized;
-}
-//#endregion
-//#region packages/ai/src/providers/anthropic-refusal.ts
-function readAnthropicRefusalDetails(value) {
-	if (!value || typeof value !== "object") return {
-		category: null,
-		explanation: null
-	};
-	const details = value;
-	return {
-		category: normalizeNullableString(details.category),
-		explanation: normalizeNullableString(details.explanation)
-	};
-}
-function formatAnthropicRefusalMessage(details) {
-	return `Anthropic refusal${details.category ? ` (category: ${details.category})` : ""}${details.explanation ? `: ${details.explanation}` : "."}`;
-}
-function applyAnthropicRefusal(output, stopDetails, provider) {
-	const details = readAnthropicRefusalDetails(stopDetails);
-	output.stopReason = "error";
-	output.errorMessage = formatAnthropicRefusalMessage(details);
-	output.diagnostics = [...output.diagnostics ?? [], {
-		type: "provider_refusal",
-		timestamp: Date.now(),
-		details: {
-			provider,
-			category: details.category,
-			explanation: details.explanation
-		}
-	}];
-}
-//#endregion
 //#region packages/ai/src/providers/anthropic-server-fallback.ts
 /** Anthropic beta that re-serves safety refusals on an allowed fallback model. */
 const ANTHROPIC_SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
@@ -594,11 +578,13 @@ function normalizeAnthropicJsonSchema(schema) {
 		delete normalized.additionalItems;
 		changed = true;
 	}
+	if (changed) delete normalized.$schema;
 	return changed ? normalized : schema;
 }
 /** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
 function projectAnthropicTools(tools, toWireName) {
 	const projectedTools = [];
+	const originalNameByWireName = /* @__PURE__ */ new Map();
 	const unavailableOriginalNames = /* @__PURE__ */ new Set();
 	for (const tool of tools) {
 		let projectedTool;
@@ -632,6 +618,7 @@ function projectAnthropicTools(tools, toWireName) {
 				wireName: toWireName(name),
 				...description ? { description } : {},
 				inputSchema: {
+					...anthropicSchema,
 					type: "object",
 					properties: properties ?? {},
 					required: required ?? []
@@ -641,8 +628,9 @@ function projectAnthropicTools(tools, toWireName) {
 			if (originalName) unavailableOriginalNames.add(originalName);
 			continue;
 		}
-		const conflictingTool = projectedTools.find((entry) => entry.wireName === projectedTool.wireName);
-		if (conflictingTool && conflictingTool.originalName !== projectedTool.originalName) throw new Error(`Anthropic tool names "${conflictingTool.originalName}" and "${projectedTool.originalName}" both map to "${projectedTool.wireName}"`);
+		const conflictingName = originalNameByWireName.get(projectedTool.wireName);
+		if (conflictingName !== void 0 && conflictingName !== projectedTool.originalName) throw new Error(`Anthropic tool names "${conflictingName}" and "${projectedTool.originalName}" both map to "${projectedTool.wireName}"`);
+		originalNameByWireName.set(projectedTool.wireName, projectedTool.originalName);
 		projectedTools.push(projectedTool);
 	}
 	return {
@@ -680,6 +668,423 @@ function resolveOriginalAnthropicToolName(name, projection) {
 	return projection?.tools.find((tool) => tool.wireName === name)?.originalName ?? name;
 }
 //#endregion
+//#region packages/ai/src/transports/anthropic-compaction-replay.ts
+const ANTHROPIC_COMPACTION_REPLAY_TYPE = "anthropic-compaction";
+const ANTHROPIC_COMPACTION_SUPPRESSION_TYPE = "anthropic-compaction-suppression";
+const ANTHROPIC_COMPACTION_SUPPRESSION_DATA = "rejected";
+function createCompactionCapture(output, model, options) {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		begin(index, block, replayIndex) {
+			if (block?.type !== "compaction") return false;
+			const content = typeof block.content === "string" ? block.content : "";
+			pending.set(index, {
+				content,
+				replayIndex
+			});
+			return true;
+		},
+		delta(index, delta) {
+			const capture = pending.get(index);
+			if (!capture || delta?.type !== "compaction_delta") return false;
+			capture.content = typeof delta.content === "string" ? delta.content : capture.content;
+			return true;
+		},
+		complete(index) {
+			const capture = pending.get(index);
+			if (!capture) return false;
+			pending.delete(index);
+			captureAnthropicCompaction(output, capture.content, capture.replayIndex, model, options);
+			return true;
+		}
+	};
+}
+function isAnthropicCompactionState(state) {
+	if (state.v !== 1 || typeof state.data !== "string" || typeof state.provider !== "string" || typeof state.api !== "string" || typeof state.model !== "string" || typeof state.baseUrlHash !== "string" || state.sessionHash !== void 0 && typeof state.sessionHash !== "string" || state.authProfileHash !== void 0 && typeof state.authProfileHash !== "string") return false;
+	if (state.type === ANTHROPIC_COMPACTION_SUPPRESSION_TYPE) return state.data === ANTHROPIC_COMPACTION_SUPPRESSION_DATA;
+	return state.type === ANTHROPIC_COMPACTION_REPLAY_TYPE && state.data.length > 0 && (state.replayIndex === void 0 || typeof state.replayIndex === "number" && Number.isSafeInteger(state.replayIndex) && state.replayIndex >= 0);
+}
+function readAnthropicCompactionState(value) {
+	return isRecord(value) && isAnthropicCompactionState(value) ? value : void 0;
+}
+function captureAnthropicCompaction(output, summary, replayIndex, model, options) {
+	const context = buildProviderReplayContext(model, options);
+	if (!summary || !context.baseUrlHash || !Number.isSafeInteger(replayIndex) || replayIndex < 0) return;
+	output.providerReplay = {
+		v: 1,
+		type: ANTHROPIC_COMPACTION_REPLAY_TYPE,
+		data: summary,
+		replayIndex,
+		...context,
+		baseUrlHash: context.baseUrlHash
+	};
+}
+function suppressAnthropicCompaction(output, model, options) {
+	const context = buildProviderReplayContext(model, options);
+	if (!context.baseUrlHash) return;
+	output.providerReplay = {
+		v: 1,
+		type: ANTHROPIC_COMPACTION_SUPPRESSION_TYPE,
+		data: ANTHROPIC_COMPACTION_SUPPRESSION_DATA,
+		...context,
+		baseUrlHash: context.baseUrlHash
+	};
+}
+function resolveNewestAnthropicCompaction(messages, model, options) {
+	const context = buildProviderReplayContext(model, options);
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role !== "assistant") continue;
+		const replayState = readAnthropicCompactionState(message.providerReplay);
+		if (replayState?.type === ANTHROPIC_COMPACTION_SUPPRESSION_TYPE) {
+			if (providerReplayContextMatches(replayState, context)) return;
+			continue;
+		}
+		if (message.providerReplay?.type !== ANTHROPIC_COMPACTION_REPLAY_TYPE) continue;
+		if (!replayState) return;
+		if (!providerReplayContextMatches(replayState, context)) return;
+		return {
+			owner: message,
+			replayIndex: replayState.replayIndex ?? 0,
+			summary: replayState.data
+		};
+	}
+}
+function buildAnthropicReplayPlan(messages, model, options) {
+	if (options?.enabled !== true) return { messages };
+	const checkpoint = resolveNewestAnthropicCompaction(messages, model, options);
+	if (!checkpoint) return { messages };
+	const ownerIndex = messages.indexOf(checkpoint.owner);
+	return {
+		messages: [{
+			...checkpoint.owner,
+			content: checkpoint.owner.content.slice(checkpoint.replayIndex)
+		}, ...messages.slice(ownerIndex + 1)],
+		compaction: {
+			type: "compaction",
+			content: checkpoint.summary
+		}
+	};
+}
+/** Match Anthropic's 400 response when a replay block is no longer accepted. */
+function isAnthropicReplayRejection(error) {
+	if (!error || typeof error !== "object") return false;
+	const record = error;
+	const nested = record.error && typeof record.error === "object" && !Array.isArray(record.error) ? record.error : void 0;
+	const text = [
+		record.message,
+		record.code,
+		nested?.message,
+		nested?.code
+	].filter((value) => typeof value === "string").join(" ").toLowerCase();
+	return (record.status === 400 || text.startsWith("http 400:")) && (text.includes("compaction") || text.includes("context_management"));
+}
+//#endregion
+//#region packages/ai/src/internal/anthropic-inline-images.ts
+const ANTHROPIC_IMAGE_MEDIA_TYPE_SET = /* @__PURE__ */ new Set([
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp"
+]);
+const ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES = 67108864;
+function createAnthropicInlineImageBudget() {
+	return { totalBytes: 0 };
+}
+function resolveAnthropicImageMediaType(value) {
+	if (ANTHROPIC_IMAGE_MEDIA_TYPE_SET.has(value)) return value;
+	throw new Error(`Unsupported Anthropic image media type after normalization: ${value}`);
+}
+async function normalizeAnthropicInlineContent(content, budget) {
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text");
+	const inputBytes = content.reduce((total, block) => block.type === "image" ? total + estimateBase64DecodedBytes(block.data) : total, 0);
+	if (budget.totalBytes + inputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
+	const normalized = [];
+	for (const block of content) {
+		if (block.type !== "image") {
+			normalized.push(block);
+			continue;
+		}
+		const normalizedBlocks = await getAiTransportHost().normalizeAnthropicInlineContentBlocks([block]);
+		const outputBytes = normalizedBlocks.reduce((total, normalizedBlock) => normalizedBlock.type === "image" ? total + estimateBase64DecodedBytes(normalizedBlock.data) : total, 0);
+		if (budget.totalBytes + outputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
+		budget.totalBytes += outputBytes;
+		normalized.push(...normalizedBlocks);
+	}
+	return normalized;
+}
+//#endregion
+//#region packages/ai/src/transports/anthropic-messages.ts
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+async function convertContentBlocks(content, model, imageBudget, profile, isError) {
+	const mediaPlaceholder = describeToolResultMediaPlaceholder(content);
+	if (!((profile === "provider" || model.input.includes("image")) && content.some(isImageWithMediaPayload))) return sanitizeNonEmptyTransportPayloadText(extractToolResultText(content), mediaPlaceholder ?? (profile === "transport" ? "(no output)" : isError ? "[tool error with no output]" : ""));
+	const blocks = [];
+	let hasTextBlock = false;
+	for (const block of content) {
+		const record = asOptionalObjectRecord(block);
+		if (!record) continue;
+		const blockText = extractToolResultBlockText(block);
+		if (blockText) {
+			blocks.push({
+				type: "text",
+				text: sanitizeTransportPayloadText(blockText)
+			});
+			hasTextBlock = true;
+		}
+		if (!isImageWithMediaPayload(record)) continue;
+		const [normalizedImage] = await normalizeAnthropicInlineContent([{
+			type: "image",
+			data: typeof record.data === "string" ? record.data : "",
+			mimeType: typeof record.mimeType === "string" ? record.mimeType : profile === "provider" ? "image/jpeg" : "image/png"
+		}], imageBudget);
+		if (normalizedImage?.type !== "image") continue;
+		blocks.push({
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: resolveAnthropicImageMediaType(normalizedImage.mimeType),
+				data: normalizedImage.data
+			}
+		});
+	}
+	if (!hasTextBlock) blocks.unshift({
+		type: "text",
+		text: mediaPlaceholder ?? "(see attached image)"
+	});
+	return blocks;
+}
+async function convertAnthropicMessages(transformedMessages, model, isOAuthToken, options) {
+	const params = [];
+	const imageBudget = createAnthropicInlineImageBudget();
+	const allowReasoningContentReplay = options.allowReasoningContentReplay === true;
+	const replayThinkingEnabled = options.replayThinkingEnabled !== false;
+	const managed = options.profile === "transport";
+	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
+	for (let i = 0; i < transformedMessages.length; i += 1) {
+		const msg = transformedMessages[i];
+		if (!msg) continue;
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				if (msg.content.trim().length > 0) {
+					const userParam = {
+						role: "user",
+						content: sanitizeTransportPayloadText(msg.content)
+					};
+					params.push(userParam);
+				}
+				continue;
+			}
+			const blocks = (!managed || model.input.includes("image") ? await normalizeAnthropicInlineContent(msg.content, imageBudget) : msg.content.map((item) => item.type === "image" ? {
+				type: "text",
+				text: NON_VISION_USER_IMAGE_PLACEHOLDER
+			} : item)).map((item) => item.type === "text" ? {
+				type: "text",
+				text: sanitizeTransportPayloadText(item.text)
+			} : {
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: resolveAnthropicImageMediaType(item.mimeType),
+					data: item.data
+				}
+			});
+			let filteredBlocks = !managed || model.input.includes("image") ? blocks : blocks.filter((block) => block.type !== "image");
+			filteredBlocks = filteredBlocks.filter((block) => block.type !== "text" || block.text.trim().length > 0);
+			if (filteredBlocks.length === 0) continue;
+			const userParam = {
+				role: "user",
+				content: filteredBlocks
+			};
+			params.push(userParam);
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const blocks = i === 0 && options.compaction ? [options.compaction] : [];
+			const reasoningContent = [];
+			let omittedThinking = false;
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (block.text.trim().length > 0) blocks.push({
+						type: "text",
+						text: sanitizeTransportPayloadText(block.text)
+					});
+					continue;
+				}
+				if (block.type === "thinking") {
+					const thinkingSignature = block.thinkingSignature?.trim();
+					const isReasoningContent = thinkingSignature === "reasoning_content";
+					if (!replayThinkingEnabled && i !== activeToolTurnAssistantIndex && (!managed || !isReasoningContent)) {
+						omittedThinking = true;
+						continue;
+					}
+					if (block.redacted) {
+						if (!managed && !block.thinkingSignature) throw new Error("redacted thinking block is missing its opaque signature");
+						blocks.push({
+							type: "redacted_thinking",
+							data: block.thinkingSignature
+						});
+						continue;
+					}
+					const hasNativeThinkingSignature = Boolean(thinkingSignature) && !isReasoningContent;
+					if (block.thinking.trim().length === 0 && !hasNativeThinkingSignature) continue;
+					if (!thinkingSignature && !options.allowEmptySignature) blocks.push({
+						type: "text",
+						text: sanitizeTransportPayloadText(block.thinking)
+					});
+					else {
+						const thinking = thinkingSignature === "reasoning_content" ? sanitizeTransportPayloadText(block.thinking) : block.thinking;
+						if (thinkingSignature === "reasoning_content") {
+							if (allowReasoningContentReplay) {
+								blocks.push({
+									type: "thinking",
+									thinking,
+									signature: thinkingSignature ?? ""
+								});
+								reasoningContent.push(thinking);
+							}
+							continue;
+						}
+						blocks.push({
+							type: "thinking",
+							thinking,
+							signature: thinkingSignature ?? ""
+						});
+					}
+					continue;
+				}
+				if (block.type === "toolCall") blocks.push({
+					type: "tool_use",
+					id: block.id,
+					name: isOAuthToken ? toClaudeCodeToolName(block.name) : block.name,
+					input: managed ? coerceTransportToolCallArguments(block.arguments) : block.arguments ?? {}
+				});
+			}
+			if (blocks.length === 0 && omittedThinking) blocks.push({
+				type: "text",
+				text: ANTHROPIC_OMITTED_REASONING_TEXT
+			});
+			if (blocks.length > 0) {
+				const assistantMsg = {
+					role: "assistant",
+					content: blocks
+				};
+				if (reasoningContent.length > 0) assistantMsg.reasoning_content = reasoningContent.join("\n");
+				else if (allowReasoningContentReplay) blocks.unshift({
+					type: "thinking",
+					thinking: "",
+					signature: "reasoning_content"
+				});
+				params.push(assistantMsg);
+			}
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			const toolResults = [];
+			let j = i;
+			while (j < transformedMessages.length) {
+				const nextMsg = transformedMessages.at(j);
+				if (nextMsg?.role !== "toolResult") break;
+				toolResults.push({
+					type: "tool_result",
+					tool_use_id: nextMsg.toolCallId,
+					content: await convertContentBlocks(nextMsg.content, model, imageBudget, options.profile, nextMsg.isError),
+					is_error: nextMsg.isError
+				});
+				j += 1;
+			}
+			i = j - 1;
+			params.push({
+				role: "user",
+				content: toolResults
+			});
+		}
+	}
+	return params;
+}
+/** Shared generation contract, after each entry point resolves its defaults and tool policy. */
+function buildAnthropicGenerationParams({ model, options, tools, toolProjection, profile }) {
+	const params = {};
+	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
+	if (options?.temperature !== void 0 && !options?.thinkingEnabled && !supportsClaudeNativeXhighEffort(model)) params.temperature = options.temperature;
+	if (options?.stop !== void 0 && options.stop.length > 0) params.stop_sequences = options.stop;
+	if (tools && tools.length > 0) params.tools = tools;
+	if (mandatoryAdaptiveThinking || model.reasoning || supportsClaudeAdaptiveThinking(model)) {
+		if (mandatoryAdaptiveThinking || options?.thinkingEnabled) {
+			const display = options?.thinkingDisplay ?? "summarized";
+			if (supportsClaudeAdaptiveThinking(model)) {
+				params.thinking = {
+					type: "adaptive",
+					display
+				};
+				const effort = options?.effort ?? (mandatoryAdaptiveThinking ? "high" : void 0);
+				if (effort) params.output_config = { effort };
+			} else params.thinking = {
+				type: "enabled",
+				budget_tokens: options?.thinkingBudgetTokens ?? 1024,
+				...profile === "provider" ? { display } : {}
+			};
+		} else if (options?.thinkingEnabled === false) params.thinking = { type: "disabled" };
+	}
+	if (options?.metadata) {
+		const userId = options.metadata.user_id;
+		if (typeof userId === "string") params.metadata = { user_id: userId };
+	}
+	if (options?.toolChoice) {
+		const normalizedToolChoice = normalizeAnthropicToolChoice(mandatoryAdaptiveThinking || options?.thinkingEnabled === true, options.toolChoice);
+		const projectedToolChoice = toolProjection ? reconcileAnthropicToolChoice(normalizedToolChoice, toolProjection) : normalizedToolChoice;
+		if (projectedToolChoice) params.tool_choice = projectedToolChoice;
+	}
+	return params;
+}
+function convertAnthropicTools(tools, isOAuthTokenLocal, supportsEagerToolInputStreaming = false) {
+	const projection = projectAnthropicTools(tools, (name) => isOAuthTokenLocal ? toClaudeCodeToolName(name) : name);
+	const convertedTools = [];
+	for (const tool of projection.tools) {
+		const convertedTool = {
+			name: tool.wireName,
+			description: tool.description,
+			input_schema: tool.inputSchema
+		};
+		if (supportsEagerToolInputStreaming) convertedTool.eager_input_streaming = true;
+		convertedTools.push(convertedTool);
+	}
+	return {
+		projection,
+		tools: convertedTools
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-refusal.ts
+function readAnthropicRefusalDetails(value) {
+	if (!value || typeof value !== "object") return {
+		category: null,
+		explanation: null
+	};
+	const details = value;
+	return {
+		category: normalizeNullableString(details.category),
+		explanation: normalizeNullableString(details.explanation)
+	};
+}
+function formatAnthropicRefusalMessage(details) {
+	return `Anthropic refusal${details.category ? ` (category: ${details.category})` : ""}${details.explanation ? `: ${details.explanation}` : "."}`;
+}
+function applyAnthropicRefusal(output, stopDetails, provider) {
+	const details = readAnthropicRefusalDetails(stopDetails);
+	output.stopReason = "error";
+	output.errorMessage = formatAnthropicRefusalMessage(details);
+	output.diagnostics = [...output.diagnostics ?? [], {
+		type: "provider_refusal",
+		timestamp: Date.now(),
+		details: {
+			provider,
+			category: details.category,
+			explanation: details.explanation
+		}
+	}];
+}
+//#endregion
 //#region packages/ai/src/providers/anthropic-usage.ts
 function readAnthropicUsageTokenCount(value) {
 	return asNonNegativeFiniteNumber(value);
@@ -812,116 +1217,453 @@ function applyAnthropicMessageDeltaUsage(target, usage, messageStartPromptUsage)
 	} else target.contextUsage = { state: "unavailable" };
 }
 //#endregion
-//#region packages/ai/src/transports/anthropic-compaction-replay.ts
-const ANTHROPIC_COMPACTION_REPLAY_TYPE = "anthropic-compaction";
-const ANTHROPIC_COMPACTION_SUPPRESSION_TYPE = "anthropic-compaction-suppression";
-const ANTHROPIC_COMPACTION_SUPPRESSION_DATA = "rejected";
-function createCompactionCapture(output, model, options) {
-	const pending = /* @__PURE__ */ new Map();
-	return {
-		begin(index, block, replayIndex) {
-			if (block?.type !== "compaction") return false;
-			const content = typeof block.content === "string" ? block.content : "";
-			pending.set(index, {
-				content,
-				replayIndex
+//#region packages/ai/src/transports/anthropic-stream-reducer.ts
+/** One Messages protocol reducer; entry points retain their established preview/replay contracts. */
+async function consumeAnthropicStream(params) {
+	const { model, options, output, stream, refusalBuffer, isOAuthToken, toolProjection } = params;
+	const managed = params.profile === "transport";
+	const eventSink = refusalBuffer ?? stream;
+	let costModel = model;
+	let messageStartPromptUsage;
+	let inputTransformations;
+	const anthropicStream = params.events;
+	try {
+		const blocks = output.content;
+		const blockIndexes = /* @__PURE__ */ new Map();
+		const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
+		const seededToolArguments = /* @__PURE__ */ new WeakMap();
+		const sealedToolCalls = [];
+		const compactionCapture = createCompactionCapture(output, model, options);
+		const pendingThinkingSignatures = /* @__PURE__ */ new Map();
+		const allowReasoningContentReplay = managed && resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
+		const reasoningContentThinkingBlocks = /* @__PURE__ */ new Map();
+		const reasoningContentTextBlocks = /* @__PURE__ */ new Map();
+		let sawMessageStop = false;
+		const pendingTextEnds = [];
+		const flushPendingTextEnds = () => {
+			for (const event of pendingTextEnds) eventSink.push(event);
+			pendingTextEnds.length = 0;
+		};
+		const emitTextEnd = (event) => {
+			if (managed) pendingTextEnds.push(event);
+			else eventSink.push(event);
+		};
+		const eventIndexKey = (eventIndex) => typeof eventIndex === "number" ? eventIndex : -1;
+		const appendReasoningContentThinkingDelta = (eventIndex, rawText) => {
+			if (typeof rawText !== "string") return false;
+			const text = sanitizeTransportPayloadText(rawText);
+			if (text.length === 0) return false;
+			const key = eventIndexKey(eventIndex);
+			let contentIndex = reasoningContentThinkingBlocks.get(key);
+			let block = contentIndex === void 0 ? void 0 : blocks[contentIndex];
+			if (!block || block.type !== "thinking") {
+				block = {
+					type: "thinking",
+					thinking: "",
+					thinkingSignature: "reasoning_content"
+				};
+				output.content.push(block);
+				contentIndex = output.content.length - 1;
+				reasoningContentThinkingBlocks.set(key, contentIndex);
+				eventSink.push({
+					type: "thinking_start",
+					contentIndex,
+					partial: output
+				});
+			}
+			if (contentIndex === void 0) return false;
+			appendAssistantThinking(block, text);
+			block.thinkingSignature = "reasoning_content";
+			eventSink.push({
+				type: "thinking_delta",
+				contentIndex,
+				delta: text,
+				partial: output
 			});
 			return true;
-		},
-		delta(index, delta) {
-			const capture = pending.get(index);
-			if (!capture || delta?.type !== "compaction_delta") return false;
-			capture.content = typeof delta.content === "string" ? delta.content : capture.content;
-			return true;
-		},
-		complete(index) {
-			const capture = pending.get(index);
-			if (!capture) return false;
-			pending.delete(index);
-			captureAnthropicCompaction(output, capture.content, capture.replayIndex, model, options);
+		};
+		const appendReasoningContentTextDelta = (eventIndex, rawText) => {
+			if (typeof rawText !== "string") return false;
+			const text = sanitizeTransportPayloadText(rawText);
+			if (text.length === 0) return false;
+			const key = eventIndexKey(eventIndex);
+			let contentIndex = reasoningContentTextBlocks.get(key);
+			let block = contentIndex === void 0 ? void 0 : blocks[contentIndex];
+			if (!block || block.type !== "text") {
+				block = {
+					type: "text",
+					text: ""
+				};
+				output.content.push(block);
+				contentIndex = output.content.length - 1;
+				reasoningContentTextBlocks.set(key, contentIndex);
+				eventSink.push({
+					type: "text_start",
+					contentIndex,
+					partial: output
+				});
+			}
+			if (contentIndex === void 0) return false;
+			block.text += text;
+			eventSink.push({
+				type: "text_delta",
+				contentIndex,
+				delta: text,
+				partial: output
+			});
 			return true;
+		};
+		const finishReasoningContentSidecars = (eventIndex) => {
+			const key = eventIndexKey(eventIndex);
+			const thinkingContentIndex = reasoningContentThinkingBlocks.get(key);
+			if (thinkingContentIndex !== void 0) {
+				reasoningContentThinkingBlocks.delete(key);
+				const block = output.content[thinkingContentIndex];
+				if (block?.type === "thinking") eventSink.push({
+					type: "thinking_end",
+					contentIndex: thinkingContentIndex,
+					content: block.thinking,
+					partial: output
+				});
+			}
+			const textContentIndex = reasoningContentTextBlocks.get(key);
+			if (textContentIndex === void 0) return;
+			reasoningContentTextBlocks.delete(key);
+			const block = output.content[textContentIndex];
+			if (block?.type === "text") eventSink.push({
+				type: "text_end",
+				contentIndex: textContentIndex,
+				content: block.text,
+				partial: output
+			});
+		};
+		for await (const rawEvent of anthropicStream) {
+			const event = asRecord(rawEvent);
+			inputTransformations = readAnthropicInputTransformations(event) ?? inputTransformations;
+			if (managed) notifyLlmRequestActivity(options.signal);
+			if (event.type === "error") {
+				const error = asOptionalObjectRecord(event.error);
+				throw new Error(readStringField(error, "message") || "Anthropic Messages stream failed");
+			}
+			if (event.type === "message_start") {
+				const message = asOptionalObjectRecord(event.message);
+				const usage = asRecord(message?.usage);
+				output.responseId = typeof message?.id === "string" ? message.id : void 0;
+				output.responseModel = typeof message?.model === "string" ? message.model : void 0;
+				messageStartPromptUsage = applyAnthropicMessageStartUsage(output.usage, usage);
+				calculateCost(costModel, output.usage);
+				eventSink.push({
+					type: "start",
+					partial: output
+				});
+				continue;
+			}
+			if (event.type === "message_stop") {
+				sawMessageStop = true;
+				continue;
+			}
+			if (event.type === "content_block_start") {
+				const contentBlock = asOptionalObjectRecord(event.content_block);
+				const index = typeof event.index === "number" ? event.index : -1;
+				if (options.anthropicServerCompaction === true && compactionCapture.begin(index, contentBlock, output.content.length)) continue;
+				const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(contentBlock) : null;
+				if (fallbackBoundary) {
+					refusalBuffer?.discard();
+					sealedToolCalls.length = 0;
+					pendingTextEnds.length = 0;
+					blockIndexes.clear();
+					pendingThinkingSignatures.clear();
+					applyAnthropicFallbackBoundary({
+						output,
+						boundary: fallbackBoundary,
+						provider: model.provider
+					});
+					costModel = {
+						...model,
+						cost: resolveAnthropicFallbackServingModelCost({
+							requestedModelId: model.id,
+							servingModelId: fallbackBoundary.toModel,
+							requestedCost: model.cost
+						})
+					};
+					calculateCost(costModel, output.usage);
+					eventSink.push({
+						type: "start",
+						partial: output
+					});
+					for (const [i, block] of blocks.entries()) {
+						if (block.type !== "text") continue;
+						delete block.index;
+						eventSink.push({
+							type: "text_start",
+							contentIndex: i,
+							partial: output
+						});
+						if (block.text) eventSink.push({
+							type: "text_delta",
+							contentIndex: i,
+							delta: block.text,
+							partial: output
+						});
+						emitTextEnd({
+							type: "text_end",
+							contentIndex: i,
+							content: block.text,
+							partial: output
+						});
+					}
+					continue;
+				}
+				pendingThinkingSignatures.delete(index);
+				if (contentBlock?.type === "text") {
+					const text = typeof contentBlock.text === "string" ? sanitizeTransportPayloadText(contentBlock.text) : "";
+					const block = {
+						type: "text",
+						text,
+						index
+					};
+					output.content.push(block);
+					const contentIndex = output.content.length - 1;
+					blockIndexes.set(index, contentIndex);
+					eventSink.push({
+						type: "text_start",
+						contentIndex,
+						partial: output
+					});
+					if (text.length > 0) eventSink.push({
+						type: "text_delta",
+						contentIndex,
+						delta: text,
+						partial: output
+					});
+					continue;
+				}
+				if (contentBlock?.type === "thinking") {
+					const thinking = typeof contentBlock.thinking === "string" ? contentBlock.thinking : "";
+					const block = {
+						type: "thinking",
+						thinking,
+						thinkingSignature: typeof contentBlock.signature === "string" ? contentBlock.signature : "",
+						index
+					};
+					output.content.push(block);
+					const contentIndex = output.content.length - 1;
+					blockIndexes.set(index, contentIndex);
+					eventSink.push({
+						type: "thinking_start",
+						contentIndex,
+						partial: output
+					});
+					if (thinking.length > 0) eventSink.push({
+						type: "thinking_delta",
+						contentIndex,
+						delta: thinking,
+						partial: output
+					});
+					continue;
+				}
+				if (contentBlock?.type === "redacted_thinking") {
+					const block = {
+						type: "thinking",
+						thinking: "[Reasoning redacted]",
+						thinkingSignature: typeof contentBlock.data === "string" ? contentBlock.data : "",
+						redacted: true,
+						index
+					};
+					output.content.push(block);
+					blockIndexes.set(index, output.content.length - 1);
+					eventSink.push({
+						type: "thinking_start",
+						contentIndex: output.content.length - 1,
+						partial: output
+					});
+					continue;
+				}
+				if (contentBlock?.type === "tool_use") {
+					if (managed) tagPendingCommentaryText(output.content);
+					flushPendingTextEnds();
+					const block = {
+						type: "toolCall",
+						id: typeof contentBlock.id === "string" ? contentBlock.id : "",
+						name: typeof contentBlock.name === "string" ? isOAuthToken ? resolveOriginalAnthropicToolName(contentBlock.name, toolProjection) : contentBlock.name : "",
+						arguments: asRecord(contentBlock.input),
+						partialJson: "",
+						index
+					};
+					output.content.push(block);
+					blockIndexes.set(index, output.content.length - 1);
+					seededToolArguments.set(block, managed ? block.arguments : contentBlock.input ?? {});
+					toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
+					eventSink.push({
+						type: "toolcall_start",
+						contentIndex: output.content.length - 1,
+						partial: output
+					});
+				}
+				continue;
+			}
+			if (event.type === "content_block_delta") {
+				const delta = asOptionalObjectRecord(event.delta);
+				const eventIndex = typeof event.index === "number" ? event.index : void 0;
+				if (eventIndex !== void 0 && compactionCapture.delta(eventIndex, delta)) continue;
+				let index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
+				let block = index === void 0 ? void 0 : blocks[index];
+				if (allowReasoningContentReplay) {
+					const appendedThinking = appendReasoningContentThinkingDelta(event.index, delta?.reasoning_content);
+					const hasNativeAnthropicDelta = delta?.type === "text_delta" && typeof delta.text === "string" || delta?.type === "thinking_delta" && typeof delta.thinking === "string" || delta?.type === "input_json_delta" && typeof delta.partial_json === "string" || delta?.type === "signature_delta" && typeof delta.signature === "string";
+					let appendedContent = false;
+					if (!hasNativeAnthropicDelta && typeof delta?.content === "string" && delta.content.length > 0) {
+						const text = sanitizeTransportPayloadText(delta.content);
+						if (text.length > 0) {
+							if (block?.type === "text" && index !== void 0) {
+								block.text += text;
+								eventSink.push({
+									type: "text_delta",
+									contentIndex: index,
+									delta: text,
+									partial: output
+								});
+								appendedContent = true;
+							} else appendedContent = appendReasoningContentTextDelta(event.index, text);
+						}
+					}
+					if ((appendedThinking || appendedContent) && !hasNativeAnthropicDelta) continue;
+				}
+				if (managed && !block && delta?.type === "text_delta" && typeof delta.text === "string") {
+					block = {
+						type: "text",
+						text: "",
+						index: typeof event.index === "number" ? event.index : blocks.length
+					};
+					output.content.push(block);
+					index = output.content.length - 1;
+					if (typeof event.index === "number") blockIndexes.set(event.index, index);
+					eventSink.push({
+						type: "text_start",
+						contentIndex: index,
+						partial: output
+					});
+				}
+				if (index === void 0) continue;
+				if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
+					block.text += delta.text;
+					eventSink.push({
+						type: "text_delta",
+						contentIndex: index,
+						delta: delta.text,
+						partial: output
+					});
+					continue;
+				}
+				if (block?.type === "thinking" && delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+					appendAssistantThinking(block, delta.thinking);
+					eventSink.push({
+						type: "thinking_delta",
+						contentIndex: index,
+						delta: delta.thinking,
+						partial: output
+					});
+					continue;
+				}
+				if (block?.type === "toolCall" && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+					const partialJson = `${block.partialJson ?? ""}${delta.partial_json}`;
+					block.partialJson = partialJson;
+					if (toolArgumentPreviewSchedules.get(block)?.(partialJson.length)) block.arguments = managed ? coerceTransportToolCallArguments(parseJsonObjectPreservingUnsafeIntegers(partialJson) ?? parseStreamingJson(partialJson)) : parseStreamingJson(partialJson);
+					eventSink.push({
+						type: "toolcall_delta",
+						contentIndex: index,
+						delta: delta.partial_json,
+						partial: output
+					});
+					continue;
+				}
+				if (block?.type === "thinking" && delta?.type === "signature_delta" && typeof delta.signature === "string") {
+					const signatureIndex = eventIndexKey(event.index);
+					const pendingSignature = pendingThinkingSignatures.get(signatureIndex);
+					if (pendingSignature === void 0) {
+						block.thinkingSignature = "";
+						pendingThinkingSignatures.set(signatureIndex, delta.signature);
+					} else pendingThinkingSignatures.set(signatureIndex, pendingSignature + delta.signature);
+				}
+				continue;
+			}
+			if (event.type === "content_block_stop") {
+				const eventIndex = typeof event.index === "number" ? event.index : void 0;
+				if (eventIndex !== void 0 && compactionCapture.complete(eventIndex)) continue;
+				const pendingSignature = eventIndex === void 0 ? void 0 : pendingThinkingSignatures.get(eventIndex);
+				if (eventIndex !== void 0) pendingThinkingSignatures.delete(eventIndex);
+				const index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
+				const block = index === void 0 ? void 0 : blocks[index];
+				if (eventIndex === void 0 || index === void 0 || !block) {
+					finishReasoningContentSidecars(event.index);
+					continue;
+				}
+				blockIndexes.delete(eventIndex);
+				delete block.index;
+				if (block.type === "text") {
+					emitTextEnd({
+						type: "text_end",
+						contentIndex: index,
+						content: block.text,
+						partial: output
+					});
+					finishReasoningContentSidecars(event.index);
+					continue;
+				}
+				if (block.type === "thinking") {
+					if (pendingSignature !== void 0) block.thinkingSignature = pendingSignature;
+					eventSink.push({
+						type: "thinking_end",
+						contentIndex: index,
+						content: block.thinking,
+						partial: output
+					});
+					finishReasoningContentSidecars(event.index);
+					continue;
+				}
+				if (block.type === "toolCall") {
+					sealedToolCalls.push({
+						block,
+						contentIndex: index
+					});
+					finishReasoningContentSidecars(event.index);
+				}
+				continue;
+			}
+			if (event.type === "message_delta") {
+				logAnthropicContextEdits(event);
+				const delta = asOptionalObjectRecord(event.delta);
+				const usage = asOptionalObjectRecord(event.usage);
+				if (typeof delta?.stop_reason === "string" && delta.stop_reason) {
+					if (delta.stop_reason === "refusal") applyAnthropicRefusal(output, delta.stop_details, model.provider);
+					else output.stopReason = mapAnthropicStopReason(delta.stop_reason);
+				}
+				applyAnthropicMessageDeltaUsage(output.usage, usage, messageStartPromptUsage);
+				calculateCost(costModel, output.usage);
+				if (managed && (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall"))) tagPendingCommentaryText(output.content);
+				flushPendingTextEnds();
+			}
 		}
-	};
-}
-function isAnthropicCompactionState(state) {
-	if (state.v !== 1 || typeof state.data !== "string" || typeof state.provider !== "string" || typeof state.api !== "string" || typeof state.model !== "string" || typeof state.baseUrlHash !== "string" || state.sessionHash !== void 0 && typeof state.sessionHash !== "string" || state.authProfileHash !== void 0 && typeof state.authProfileHash !== "string") return false;
-	if (state.type === ANTHROPIC_COMPACTION_SUPPRESSION_TYPE) return state.data === ANTHROPIC_COMPACTION_SUPPRESSION_DATA;
-	return state.type === ANTHROPIC_COMPACTION_REPLAY_TYPE && state.data.length > 0 && (state.replayIndex === void 0 || typeof state.replayIndex === "number" && Number.isSafeInteger(state.replayIndex) && state.replayIndex >= 0);
-}
-function readAnthropicCompactionState(value) {
-	return isRecord(value) && isAnthropicCompactionState(value) ? value : void 0;
-}
-function captureAnthropicCompaction(output, summary, replayIndex, model, options) {
-	const context = buildProviderReplayContext(model, options);
-	if (!summary || !context.baseUrlHash || !Number.isSafeInteger(replayIndex) || replayIndex < 0) return;
-	output.providerReplay = {
-		v: 1,
-		type: ANTHROPIC_COMPACTION_REPLAY_TYPE,
-		data: summary,
-		replayIndex,
-		...context,
-		baseUrlHash: context.baseUrlHash
-	};
-}
-function suppressAnthropicCompaction(output, model, options) {
-	const context = buildProviderReplayContext(model, options);
-	if (!context.baseUrlHash) return;
-	output.providerReplay = {
-		v: 1,
-		type: ANTHROPIC_COMPACTION_SUPPRESSION_TYPE,
-		data: ANTHROPIC_COMPACTION_SUPPRESSION_DATA,
-		...context,
-		baseUrlHash: context.baseUrlHash
-	};
-}
-function resolveNewestAnthropicCompaction(messages, model, options) {
-	const context = buildProviderReplayContext(model, options);
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "assistant") continue;
-		const replayState = readAnthropicCompactionState(message.providerReplay);
-		if (replayState?.type === ANTHROPIC_COMPACTION_SUPPRESSION_TYPE) {
-			if (providerReplayContextMatches(replayState, context)) return;
-			continue;
+		if ((isDirectAnthropicModel(model) || !managed && refusalBuffer) && !sawMessageStop) throw new Error("Anthropic stream ended before message_stop");
+		if (options.signal?.aborted) throw transportAbortError(options.signal);
+		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+		if ([...blockIndexes.values()].some((index) => blocks[index]?.type === "toolCall")) throw new Error("Provider completed stream with an incomplete tool call");
+		finalizeTerminalToolCallArguments(sealedToolCalls.map(({ block }) => block), (block) => block.partialJson && block.partialJson.length > 0 ? block.partialJson : seededToolArguments.get(block));
+		for (const sealed of sealedToolCalls) {
+			delete sealed.block.partialJson;
+			eventSink.push({
+				type: "toolcall_end",
+				contentIndex: sealed.contentIndex,
+				toolCall: sealed.block,
+				partial: output
+			});
 		}
-		if (message.providerReplay?.type !== ANTHROPIC_COMPACTION_REPLAY_TYPE) continue;
-		if (!replayState) return;
-		if (!providerReplayContextMatches(replayState, context)) return;
-		return {
-			owner: message,
-			replayIndex: replayState.replayIndex ?? 0,
-			summary: replayState.data
-		};
+		refusalBuffer?.flush();
+		if (managed && (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall"))) tagPendingCommentaryText(output.content);
+		flushPendingTextEnds();
+	} finally {
+		logAnthropicThinkingDrops(inputTransformations);
 	}
 }
-function buildAnthropicReplayPlan(messages, model, options) {
-	if (options?.enabled !== true) return { messages };
-	const checkpoint = resolveNewestAnthropicCompaction(messages, model, options);
-	if (!checkpoint) return { messages };
-	const ownerIndex = messages.indexOf(checkpoint.owner);
-	return {
-		messages: [{
-			...checkpoint.owner,
-			content: checkpoint.owner.content.slice(checkpoint.replayIndex)
-		}, ...messages.slice(ownerIndex + 1)],
-		compaction: {
-			type: "compaction",
-			content: checkpoint.summary
-		}
-	};
-}
-/** Match Anthropic's 400 response when a replay block is no longer accepted. */
-function isAnthropicReplayRejection(error) {
-	if (!error || typeof error !== "object") return false;
-	const record = error;
-	const nested = record.error && typeof record.error === "object" && !Array.isArray(record.error) ? record.error : void 0;
-	const text = [
-		record.message,
-		record.code,
-		nested?.message,
-		nested?.code
-	].filter((value) => typeof value === "string").join(" ").toLowerCase();
-	return (record.status === 400 || text.startsWith("http 400:")) && (text.includes("compaction") || text.includes("context_management"));
-}
 //#endregion
-export { createAnthropicInlineImageBudget as A, resolveAnthropicContextManagementBetaHeader as B, ANTHROPIC_SERVER_SIDE_FALLBACKS as C, readAnthropicFallbackBoundary as D, applyAnthropicFallbackBoundary as E, applyAnthropicEphemeralCacheControlMarkers as F, omitFoundryBearerCredentialHeaders as G, resolveAnthropicPayloadPolicy as H, applyAnthropicPayloadPolicyToParams as I, usesFoundryBearerAuth as K, isAnthropicServerToolClearingEnabled as L, resolveAnthropicImageMediaType as M, applyAnthropicCacheControlToMessages as N, resolveAnthropicFallbackServingModelCost as O, applyAnthropicContextManagementToRequest as P, isDirectAnthropicModel as R, readAnthropicInputTransformations as S, CLAUDE_OPUS_FALLBACK_MODEL_COST as T, resolveAnthropicServerCompactionPlan as U, resolveAnthropicEphemeralCacheControl as V, isAnthropicOAuthApiKey as W, toClaudeCodeToolName as _, suppressAnthropicCompaction as a, findActiveAnthropicToolTurnAssistantIndex as b, readAnthropicCacheWriteUsage as c, readLastAnthropicIterationUsage as d, normalizeAnthropicToolCallId as f, resolveOriginalAnthropicToolName as g, reconcileAnthropicToolChoice as h, resolveNewestAnthropicCompaction as i, normalizeAnthropicInlineContent as j, applyAnthropicRefusal as k, readAnthropicPromptUsageSnapshot as l, projectAnthropicTools as m, createCompactionCapture as n, applyAnthropicMessageDeltaUsage as o, normalizeAnthropicToolChoice as p, isAnthropicReplayRejection as r, applyAnthropicMessageStartUsage as s, buildAnthropicReplayPlan as t, readAnthropicUsageTokenCount as u, ANTHROPIC_OMITTED_REASONING_TEXT as v, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as w, logAnthropicThinkingDrops as x, applyAnthropicThinkingBindingControls as y, logAnthropicContextEdits as z };
+export { applyAnthropicFallbackBoundary as A, logAnthropicContextEdits as B, applyAnthropicThinkingBindingControls as C, ANTHROPIC_SERVER_SIDE_FALLBACKS as D, readAnthropicInputTransformations as E, applyAnthropicPayloadPolicyToParams as F, resolveAnthropicServerCompactionPlan as G, resolveAnthropicContextManagementBetaHeader as H, applyAnthropicRequestCacheControl as I, usesFoundryBearerAuth as J, isAnthropicOAuthApiKey as K, buildAnthropicSystemBlocks as L, resolveAnthropicFallbackServingModelCost as M, applyAnthropicContextManagementToRequest as N, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as O, applyAnthropicEphemeralCacheControlMarkers as P, isAnthropicServerToolClearingEnabled as R, ANTHROPIC_OMITTED_REASONING_TEXT as S, logAnthropicThinkingDrops as T, resolveAnthropicEphemeralCacheControl as U, resolveAnthropicCacheOptions as V, resolveAnthropicPayloadPolicy as W, normalizeAnthropicToolChoice as _, readAnthropicPromptUsageSnapshot as a, resolveOriginalAnthropicToolName as b, applyAnthropicRefusal as c, convertAnthropicTools as d, buildAnthropicReplayPlan as f, normalizeAnthropicToolCallId as g, suppressAnthropicCompaction as h, readAnthropicCacheWriteUsage as i, readAnthropicFallbackBoundary as j, CLAUDE_OPUS_FALLBACK_MODEL_COST as k, buildAnthropicGenerationParams as l, resolveNewestAnthropicCompaction as m, applyAnthropicMessageDeltaUsage as n, readAnthropicUsageTokenCount as o, isAnthropicReplayRejection as p, omitFoundryBearerCredentialHeaders as q, applyAnthropicMessageStartUsage as r, readLastAnthropicIterationUsage as s, consumeAnthropicStream as t, convertAnthropicMessages as u, projectAnthropicTools as v, findActiveAnthropicToolTurnAssistantIndex as w, toClaudeCodeToolName as x, reconcileAnthropicToolChoice as y, isDirectAnthropicModel as z };