@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/{anthropic-CE-7SkF6.mjs → anthropic-B8KwTtlb.mjs}

@@ -1,20 +1,19 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./src-QkygScBs.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { a as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, d as requiresClaudeAdaptiveThinking, f as resolveAnthropicThinkingEffort, h as usesClaudeStreamingRefusalContract, i as transformMessages, l as mapAnthropicStopReason, m as usesClaudeFable5MessagesContract, n as getAiTransportHost, o as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as applyClaudeRequestContract, u as prepareClaudeNoPrefillRequestContext } from "./host-Bl7Kgddo.mjs";
-import { n as calculateCost } from "./model-utils-Dau5dlgm.mjs";
+import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./anthropic-BQXQudmA.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
+import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-DF_yxOsA.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, c as buildBaseOptions, h as stripSystemPromptCacheBoundary, l as clampMaxTokensToModel, m as splitSystemPromptCacheBoundary, n as extractToolResultBlockText, r as extractToolResultText, s as adjustMaxTokensForThinking, t as describeToolResultMediaPlaceholder } from "./tool-result-text-Dvkp2Dus.mjs";
-import { C as usesFoundryBearerAuth, E as resolveAnthropicImageMediaType, O as applyAnthropicCacheControlToMessages, S as omitFoundryBearerCredentialHeaders, T as normalizeAnthropicInlineContent, b as resolveAnthropicFallbackServingModelCost, c as normalizeAnthropicToolChoice, d as resolveOriginalAnthropicToolName, f as toClaudeCodeToolName, g as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, h as ANTHROPIC_SERVER_SIDE_FALLBACKS, l as projectAnthropicTools, m as findActiveAnthropicToolTurnAssistantIndex, n as applyAnthropicMessageStartUsage, p as ANTHROPIC_OMITTED_REASONING_TEXT, s as normalizeAnthropicToolCallId, t as applyAnthropicMessageDeltaUsage, u as reconcileAnthropicToolChoice, v as applyAnthropicFallbackBoundary, w as createAnthropicInlineImageBudget, x as applyAnthropicRefusal, y as readAnthropicFallbackBoundary } from "./anthropic-usage-Ma4iX6uG.mjs";
+import { A as splitSystemPromptCacheBoundary, d as finalizeTerminalToolCallArguments, g as notifyProviderHttpResponse, j as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel, t as adjustMaxTokensForThinking, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
+import { A as resolveAnthropicImageMediaType, C as readAnthropicFallbackBoundary, D as usesFoundryBearerAuth, E as omitFoundryBearerCredentialHeaders, O as createAnthropicInlineImageBudget, S as applyAnthropicFallbackBoundary, T as applyAnthropicRefusal, _ as ANTHROPIC_OMITTED_REASONING_TEXT, a as applyAnthropicMessageDeltaUsage, b as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, d as normalizeAnthropicToolCallId, f as normalizeAnthropicToolChoice, g as toClaudeCodeToolName, h as resolveOriginalAnthropicToolName, i as suppressAnthropicCompaction, j as applyAnthropicCacheControlToMessages, k as normalizeAnthropicInlineContent, m as reconcileAnthropicToolChoice, n as createCompactionCapture, o as applyAnthropicMessageStartUsage, p as projectAnthropicTools, r as isAnthropicReplayRejection, t as buildAnthropicReplayPlan, v as findActiveAnthropicToolTurnAssistantIndex, w as resolveAnthropicFallbackServingModelCost, y as ANTHROPIC_SERVER_SIDE_FALLBACKS } from "./anthropic-compaction-replay-4Zx7-aCr.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as parseStreamingJson, t as parseJsonWithRepair } from "./json-parse-BvXNt1-7.mjs";
+import { n as parseStreamingJson, t as parseJsonWithRepair } from "./json-parse-CDnesDM_.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { d as transportAbortError, f as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-stream-shared-CPNv7A3r.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-DI0Ts28U.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-Bv0FHkd0.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform--gtf0ZbR.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import "./transform-messages-DfjpNXNQ.mjs";
 import Anthropic from "@anthropic-ai/sdk";
 import { Stream } from "@anthropic-ai/sdk/core/streaming.js";
 //#region packages/ai/src/providers/anthropic.ts
@@ -159,6 +158,7 @@ const streamAnthropic = (model, context, options) => {
 		const eventSink = refusalBuffer ?? stream;
 		let costModel = model;
 		let messageStartPromptUsage;
+		let usedCompactionReplay = false;
 		try {
 			let client;
 			let isOAuth;
@@ -183,6 +183,7 @@ const streamAnthropic = (model, context, options) => {
 				serverSideFallback = created.serverSideFallback;
 			}
 			const builtParams = await buildParams(model, requestContext, isOAuth, requestOptions, serverSideFallback);
+			usedCompactionReplay = builtParams.usedCompactionReplay;
 			let params = builtParams.params;
 			const toolProjection = builtParams.toolProjection;
 			const nextParams = await requestOptions?.onPayload?.(params, model);
@@ -197,12 +198,15 @@ const streamAnthropic = (model, context, options) => {
 				...params,
 				stream: true
 			}, sdkRequestOptions).asResponse();
-			await requestOptions?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
+			await notifyProviderHttpResponse({
+				options: requestOptions,
+				response,
+				model
+			});
 			const blocks = output.content;
 			const blockIndexes = /* @__PURE__ */ new Map();
+			const sealedToolCalls = [];
+			const compactionCapture = createCompactionCapture(output, model, requestOptions);
 			for await (const event of iterateAnthropicEvents(response, refusalBuffer !== void 0)) if (event.type === "message_start") {
 				output.responseId = event.message.id;
 				output.responseModel = event.message.model;
@@ -213,9 +217,12 @@ const streamAnthropic = (model, context, options) => {
 					partial: output
 				});
 			} else if (event.type === "content_block_start") {
+				const rawContentBlock = isRecord(event.content_block) ? event.content_block : void 0;
+				if (requestOptions?.anthropicServerCompaction === true && compactionCapture.begin(event.index, rawContentBlock, output.content.length)) continue;
 				const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(event.content_block) : null;
 				if (fallbackBoundary) {
 					refusalBuffer?.discard();
+					sealedToolCalls.length = 0;
 					blockIndexes.clear();
 					applyAnthropicFallbackBoundary({
 						output,
@@ -316,7 +323,9 @@ const streamAnthropic = (model, context, options) => {
 					});
 				}
 			} else if (event.type === "content_block_delta") {
-				if (event.delta.type === "text_delta") {
+				const rawDelta = isRecord(event.delta) ? event.delta : void 0;
+				if (compactionCapture.delta(event.index, rawDelta)) continue;
+				else if (event.delta.type === "text_delta") {
 					const index = blockIndexes.get(event.index);
 					const block = index === void 0 ? void 0 : blocks[index];
 					if (index !== void 0 && block?.type === "text") {
@@ -344,7 +353,7 @@ const streamAnthropic = (model, context, options) => {
 					const index = blockIndexes.get(event.index);
 					const block = index === void 0 ? void 0 : blocks[index];
 					if (index !== void 0 && block?.type === "toolCall") {
-						block.partialJson += event.delta.partial_json;
+						block.partialJson = (block.partialJson ?? "") + event.delta.partial_json;
 						block.arguments = parseStreamingJson(block.partialJson);
 						eventSink.push({
 							type: "toolcall_delta",
@@ -362,6 +371,7 @@ const streamAnthropic = (model, context, options) => {
 					}
 				}
 			} else if (event.type === "content_block_stop") {
+				if (compactionCapture.complete(event.index)) continue;
 				const index = blockIndexes.get(event.index);
 				const block = index === void 0 ? void 0 : blocks[index];
 				if (index !== void 0 && block) {
@@ -379,16 +389,10 @@ const streamAnthropic = (model, context, options) => {
 						content: block.thinking,
 						partial: output
 					});
-					else if (block.type === "toolCall") {
-						block.arguments = parseStreamingJson(block.partialJson);
-						delete block.partialJson;
-						eventSink.push({
-							type: "toolcall_end",
-							contentIndex: index,
-							toolCall: block,
-							partial: output
-						});
-					}
+					else if (block.type === "toolCall") sealedToolCalls.push({
+						block,
+						contentIndex: index
+					});
 				}
 			} else if (event.type === "message_delta") {
 				if (event.delta.stop_reason) if (event.delta.stop_reason === "refusal") applyAnthropicRefusal(output, event.delta.stop_details, model.provider);
@@ -398,6 +402,17 @@ const streamAnthropic = (model, context, options) => {
 			}
 			if (requestOptions?.signal?.aborted) throw transportAbortError(requestOptions.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 : block.arguments);
+			for (const sealed of sealedToolCalls) {
+				delete sealed.block.partialJson;
+				eventSink.push({
+					type: "toolcall_end",
+					contentIndex: sealed.contentIndex,
+					toolCall: sealed.block,
+					partial: output
+				});
+			}
 			refusalBuffer?.flush();
 			stream.push({
 				type: "done",
@@ -406,6 +421,7 @@ const streamAnthropic = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
+			output.content = output.content.filter((block) => block.type !== "toolCall");
 			for (const block of output.content) {
 				delete block.index;
 				delete block.partialJson;
@@ -414,11 +430,12 @@ const streamAnthropic = (model, context, options) => {
 				refusalBuffer.discard();
 				output.content = [];
 			}
-			output.stopReason = requestOptions?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = formatProviderError(error);
+			if (usedCompactionReplay && isAnthropicReplayRejection(error)) suppressAnthropicCompaction(output, model, requestOptions);
+			const terminal = projectProviderError(error, requestOptions?.signal);
+			Object.assign(output, terminal);
 			stream.push({
 				type: "error",
-				reason: output.stopReason,
+				reason: terminal.stopReason,
 				error: output
 			});
 			stream.end();
@@ -442,6 +459,8 @@ const streamSimpleAnthropic = (model, context, options) => {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const base = {
 		...buildBaseOptions(model, options, apiKey),
+		anthropicServerCompaction: options?.anthropicServerCompaction,
+		authProfileId: options?.authProfileId,
 		maxTokens: clampMaxTokensToModel(model, options?.maxTokens ?? model.maxTokens),
 		toolChoice: options?.toolChoice
 	};
@@ -612,9 +631,14 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 	const systemCacheControlCount = countNativeCacheControlMarkers(system);
 	const toolCacheControlCount = countNativeCacheControlMarkers(tools);
 	const messageCacheControlLimit = Math.max(0, ANTHROPIC_CACHE_CONTROL_LIMIT - systemCacheControlCount - toolCacheControlCount);
+	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
+		enabled: !isOAuthTokenResult && options?.anthropicServerCompaction === true,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId
+	});
 	const params = {
 		model: model.id,
-		messages: await convertMessages(context.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled, compat.allowEmptySignature),
+		messages: await convertMessages(replayPlan.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled, compat.allowEmptySignature, replayPlan.compaction),
 		max_tokens: options?.maxTokens ?? model.maxTokens,
 		stream: true
 	};
@@ -632,7 +656,7 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 					display
 				};
 				const effort = options?.effort ?? (mandatoryAdaptiveThinking ? "high" : void 0);
-				if (effort) params.output_config = effort === "xhigh" ? { effort } : { effort };
+				if (effort) params.output_config = { effort };
 			} else params.thinking = {
 				type: "enabled",
 				budget_tokens: options?.thinkingBudgetTokens ?? ANTHROPIC_MIN_THINKING_BUDGET_TOKENS,
@@ -651,14 +675,15 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 	}
 	return {
 		params,
-		toolProjection
+		toolProjection,
+		usedCompactionReplay: replayPlan.compaction !== void 0
 	};
 }
-async function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true, allowEmptySignature = false) {
+async function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true, allowEmptySignature = false, compaction) {
 	const params = [];
 	const imageBudget = createAnthropicInlineImageBudget();
 	const cacheBreakpointOptOutParamIndexes = /* @__PURE__ */ new Set();
-	const transformedMessages = transformMessages(messages, model, normalizeAnthropicToolCallId);
+	const transformedMessages = transformProviderMessages(messages, model, normalizeAnthropicToolCallId);
 	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
 	for (let i = 0; i < transformedMessages.length; i++) {
 		const msg = transformedMessages[i];
@@ -699,7 +724,7 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 				});
 			}
 		} else if (msg.role === "assistant") {
-			const blocks = [];
+			const blocks = i === 0 && compaction ? [compaction] : [];
 			let omittedThinking = false;
 			for (const block of msg.content) if (block.type === "text") {
 				if (block.text.trim().length === 0) continue;

package/dist/{anthropic-SrGtwsJu.d.mts → anthropic-BECQCNdF.d.mts}

@@ -8,8 +8,6 @@ type ClaudeEffortModelRef = ClaudeModelRef & {
 };
 declare const CLAUDE_FABLE_5_THINKING_PROFILE: {
   readonly levels: readonly [{
-    readonly id: "off";
-  }, {
     readonly id: "minimal";
   }, {
     readonly id: "low";

package/dist/{src-QkygScBs.mjs → anthropic-BQXQudmA.mjs}

@@ -1,4 +1,3 @@
-import "./validation-DAa_yFOM.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -6,7 +5,6 @@ function normalizeClaudeModelId(modelId) {
 }
 const CLAUDE_FABLE_5_THINKING_PROFILE = {
 	levels: [
-		{ id: "off" },
 		{ id: "minimal" },
 		{ id: "low" },
 		{ id: "medium" },

package/dist/{anthropic-usage-Ma4iX6uG.mjs → anthropic-compaction-replay-4Zx7-aCr.mjs}

@@ -1,8 +1,13 @@
-import { o as resolveClaudeFable5ModelIdentity, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "./src-QkygScBs.mjs";
-import { b as isRecord, n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { o as resolveClaudeFable5ModelIdentity, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "./anthropic-BQXQudmA.mjs";
+import { i as normalizeOptionalLowercaseString, r as normalizeNullableString } from "./string-coerce-fsri9iCu.mjs";
+import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { a as estimateBase64DecodedBytes } from "./provider-error-C8mBRJDl.mjs";
+import { r as asNonNegativeFiniteNumber, s as parseStrictPositiveInteger } from "./number-coercion-H9qHik3g.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { h as stripSystemPromptCacheBoundary, m as splitSystemPromptCacheBoundary, v as sortPromptCacheToolsByName } from "./tool-result-text-Dvkp2Dus.mjs";
-import { o as resolveProviderRequestCapabilities, t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-B1b-XCn5.mjs";
+import { A as splitSystemPromptCacheBoundary, P as sortPromptCacheToolsByName, j as stripSystemPromptCacheBoundary } from "./simple-options-oqsXB6U3.mjs";
+import { a as resolveProviderEndpoint, o as resolveProviderRequestCapabilities, t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-FEr-jOoZ.mjs";
+import { t as shortHash } from "./hash-CHgqbJmD.mjs";
 //#region packages/ai/src/transports/anthropic-payload-policy.ts
 /**
 * Anthropic-family request payload policy helpers.
@@ -10,6 +15,29 @@ import { o as resolveProviderRequestCapabilities, t as projectRuntimeToolInputSc
 * capabilities allow them.
 */
 const ANTHROPIC_CACHE_CONTROL_LIMIT = 4;
+const ANTHROPIC_COMPACT_THRESHOLD_MIN = 5e4;
+function parsePositiveInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	return typeof value === "string" ? parseStrictPositiveInteger(value) : void 0;
+}
+/** Resolve the Anthropic input-token trigger, including the API's minimum. */
+function resolveAnthropicCompactThreshold(contextWindow, configured) {
+	const configuredThreshold = parsePositiveInteger(configured);
+	if (configuredThreshold !== void 0) return Math.max(ANTHROPIC_COMPACT_THRESHOLD_MIN, configuredThreshold);
+	const resolvedContextWindow = parsePositiveInteger(contextWindow);
+	return Math.max(ANTHROPIC_COMPACT_THRESHOLD_MIN, resolvedContextWindow === void 0 ? ANTHROPIC_COMPACT_THRESHOLD_MIN : Math.floor(resolvedContextWindow * .7));
+}
+/** Resolve the server-compaction gate and effective threshold for an Anthropic route. */
+function resolveAnthropicServerCompactionPlan(model, extraParams) {
+	const provider = normalizeOptionalLowercaseString(model.provider);
+	const api = normalizeOptionalLowercaseString(model.api);
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
+	const enabled = extraParams?.anthropicServerCompaction === true && provider === "anthropic" && api === "anthropic-messages" && (endpointClass === "default" || endpointClass === "anthropic-public");
+	return {
+		enabled,
+		...enabled ? { threshold: resolveAnthropicCompactThreshold(model.contextWindow, extraParams?.anthropicCompactThreshold) } : {}
+	};
+}
 function resolveBaseUrlHostname(baseUrl) {
 	try {
 		return new URL(baseUrl).hostname;
@@ -122,17 +150,21 @@ function countAnthropicCacheControlMarkers(blocks) {
 	return count;
 }
 /** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
-function resolveAnthropicPayloadPolicy(input) {
+function resolveAnthropicPayloadPolicy(input, model) {
+	const capabilities = resolveProviderRequestCapabilities({
+		provider: input.provider,
+		api: input.api,
+		baseUrl: input.baseUrl,
+		capability: "llm",
+		transport: "stream"
+	}, model);
+	const serverCompactionPlan = resolveAnthropicServerCompactionPlan(input, input.extraParams);
 	return {
-		allowsServiceTier: resolveProviderRequestCapabilities({
-			provider: input.provider,
-			api: input.api,
-			baseUrl: input.baseUrl,
-			capability: "llm",
-			transport: "stream"
-		}).allowsAnthropicServiceTier,
+		allowsServiceTier: capabilities.allowsAnthropicServiceTier,
 		cacheControl: input.enableCacheControl === true ? resolveAnthropicEphemeralCacheControl(input.baseUrl, input.cacheRetention) : void 0,
-		serviceTier: input.serviceTier
+		compactThreshold: serverCompactionPlan.threshold ?? resolveAnthropicCompactThreshold(input.contextWindow, input.extraParams?.anthropicCompactThreshold),
+		serviceTier: input.serviceTier,
+		useServerCompaction: input.enableServerCompaction === true && serverCompactionPlan.enabled
 	};
 }
 /** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
@@ -140,6 +172,13 @@ function applyAnthropicPayloadPolicyToParams(payloadObj, policy, cacheBreakpoint
 	if (policy.allowsServiceTier && policy.serviceTier !== void 0 && payloadObj.service_tier === void 0) payloadObj.service_tier = policy.serviceTier;
 	if (policy.cacheControl) applyAnthropicCacheControlToSystem(payloadObj.system, policy.cacheControl);
 	else stripAnthropicSystemPromptBoundary(payloadObj.system);
+	if (policy.useServerCompaction && payloadObj.context_management === void 0) payloadObj.context_management = { edits: [{
+		type: "compact_20260112",
+		trigger: {
+			type: "input_tokens",
+			value: policy.compactThreshold
+		}
+	}] };
 	if (!policy.cacheControl) return;
 	const usedMarkers = countAnthropicCacheControlMarkers(payloadObj.system) + countAnthropicCacheControlMarkers(payloadObj.tools);
 	applyAnthropicCacheControlToMessages(payloadObj.messages, policy.cacheControl, ANTHROPIC_CACHE_CONTROL_LIMIT - usedMarkers, cacheBreakpointOptOutMessageIndexes);
@@ -176,83 +215,6 @@ function applyAnthropicEphemeralCacheControlMarkers(payloadObj, cacheControl = {
 	}
 }
 //#endregion
-//#region packages/media-core/src/base64.ts
-/** Estimates decoded bytes without allocating a cleaned copy of the base64 payload. */
-function estimateBase64DecodedBytes(base64) {
-	let effectiveLen = 0;
-	for (let i = 0; i < base64.length; i += 1) {
-		if (base64.charCodeAt(i) <= 32) continue;
-		effectiveLen += 1;
-	}
-	if (effectiveLen === 0) return 0;
-	let padding = 0;
-	let end = base64.length - 1;
-	while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
-	if (end >= 0 && base64[end] === "=") {
-		padding = 1;
-		end -= 1;
-		while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
-		if (end >= 0 && base64[end] === "=") padding = 2;
-	}
-	const estimated = Math.floor(effectiveLen * 3 / 4) - padding;
-	return Math.max(0, estimated);
-}
-const CANONICALIZE_BASE64_CHUNK_SIZE = 8192;
-function isBase64DataChar(code) {
-	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
-}
-function base64DataValue(code) {
-	if (code >= 65 && code <= 90) return code - 65;
-	if (code >= 97 && code <= 122) return code - 97 + 26;
-	if (code >= 48 && code <= 57) return code - 48 + 52;
-	return code === 43 ? 62 : 63;
-}
-/**
-* Normalizes and validates a base64 string, returning canonical no-whitespace
-* base64 only when the input has valid alphabet, padding, and length.
-*/
-function canonicalizeBase64(base64) {
-	const chunks = [];
-	let current = "";
-	let cleanedLength = 0;
-	let padding = 0;
-	let sawPadding = false;
-	let lastDataCode = 0;
-	const append = (char) => {
-		current += char;
-		cleanedLength += 1;
-		if (current.length >= CANONICALIZE_BASE64_CHUNK_SIZE) {
-			chunks.push(current);
-			current = "";
-		}
-	};
-	for (let i = 0; i < base64.length; i += 1) {
-		const code = base64.charCodeAt(i);
-		if (code <= 32) continue;
-		if (code === 61) {
-			padding += 1;
-			if (padding > 2) return;
-			sawPadding = true;
-			append("=");
-			continue;
-		}
-		if (sawPadding || !isBase64DataChar(code)) return;
-		lastDataCode = code;
-		append(base64[i] ?? "");
-	}
-	if (cleanedLength === 0) return;
-	const remainder = cleanedLength % 4;
-	if (remainder !== 0) {
-		if (sawPadding || remainder === 1) return;
-		current += "=".repeat(4 - remainder);
-	}
-	const effectivePadding = remainder === 0 ? padding : 4 - remainder;
-	const padBitMask = effectivePadding === 2 ? 15 : effectivePadding === 1 ? 3 : 0;
-	if (padBitMask !== 0 && (base64DataValue(lastDataCode) & padBitMask) !== 0) return;
-	if (current) chunks.push(current);
-	return chunks.join("");
-}
-//#endregion
 //#region packages/ai/src/internal/anthropic-inline-images.ts
 const ANTHROPIC_IMAGE_MEDIA_TYPE_SET = /* @__PURE__ */ new Set([
 	"image/jpeg",
@@ -307,9 +269,6 @@ function omitFoundryBearerCredentialHeaders(headers) {
 }
 //#endregion
 //#region packages/ai/src/providers/anthropic-refusal.ts
-function readNullableString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : null;
-}
 function readAnthropicRefusalDetails(value) {
 	if (!value || typeof value !== "object") return {
 		category: null,
@@ -317,8 +276,8 @@ function readAnthropicRefusalDetails(value) {
 	};
 	const details = value;
 	return {
-		category: readNullableString(details.category),
-		explanation: readNullableString(details.explanation)
+		category: normalizeNullableString(details.category),
+		explanation: normalizeNullableString(details.explanation)
 	};
 }
 function formatAnthropicRefusalMessage(details) {
@@ -618,7 +577,7 @@ function resolveOriginalAnthropicToolName(name, projection) {
 //#endregion
 //#region packages/ai/src/providers/anthropic-usage.ts
 function readAnthropicUsageTokenCount(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+	return asNonNegativeFiniteNumber(value);
 }
 function readAnthropicCacheWriteUsage(usage) {
 	if (!usage.cache_creation || typeof usage.cache_creation !== "object") return {};
@@ -661,6 +620,33 @@ function readLastAnthropicIterationUsage(usage) {
 		}
 	};
 }
+function readAnthropicCompactionBilledUsage(iterations) {
+	if (!Array.isArray(iterations) || iterations.length === 0) return;
+	let sawCompaction = false;
+	const billed = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		cacheWrite1h: 0
+	};
+	for (const iteration of iterations) {
+		if (!iteration || typeof iteration !== "object" || Array.isArray(iteration)) return;
+		const record = iteration;
+		const input = readAnthropicUsageTokenCount(record.input_tokens);
+		const output = readAnthropicUsageTokenCount(record.output_tokens);
+		const cacheRead = readAnthropicUsageTokenCount(record.cache_read_input_tokens);
+		const cacheWrite = readAnthropicUsageTokenCount(record.cache_creation_input_tokens);
+		if (input === void 0 || output === void 0 || cacheRead === void 0 || cacheWrite === void 0) return;
+		sawCompaction ||= record.type === "compaction";
+		billed.input += input;
+		billed.output += output;
+		billed.cacheRead += cacheRead;
+		billed.cacheWrite += cacheWrite;
+		billed.cacheWrite1h += readAnthropicCacheWriteUsage(record).cacheWrite1h ?? 0;
+	}
+	return sawCompaction ? billed : void 0;
+}
 /** Record independent billing buckets without treating zero placeholders as context proof. */
 function applyAnthropicMessageStartUsage(target, payload) {
 	const promptUsage = readAnthropicPromptUsageSnapshot(payload);
@@ -686,16 +672,23 @@ function applyAnthropicMessageStartUsage(target, payload) {
 /** Keep cumulative billing separate from the final server-side iteration context. */
 function applyAnthropicMessageDeltaUsage(target, payload, messageStartPromptUsage) {
 	const usage = payload ?? {};
+	const billedIterations = readAnthropicCompactionBilledUsage(usage.iterations);
 	const inputTokens = readAnthropicUsageTokenCount(usage.input_tokens);
-	if (inputTokens !== void 0) target.input = inputTokens;
 	const outputTokens = readAnthropicUsageTokenCount(usage.output_tokens);
-	if (outputTokens !== void 0) target.output = outputTokens;
 	const cacheReadTokens = readAnthropicUsageTokenCount(usage.cache_read_input_tokens);
-	if (cacheReadTokens !== void 0) target.cacheRead = cacheReadTokens;
 	const cacheWriteTokens = readAnthropicUsageTokenCount(usage.cache_creation_input_tokens);
-	if (cacheWriteTokens !== void 0) target.cacheWrite = cacheWriteTokens;
-	const { cacheWrite1h } = readAnthropicCacheWriteUsage(usage);
-	if (cacheWrite1h !== void 0) target.cacheWrite1h = cacheWrite1h;
+	const resolved = billedIterations ?? {
+		input: inputTokens,
+		output: outputTokens,
+		cacheRead: cacheReadTokens,
+		cacheWrite: cacheWriteTokens,
+		cacheWrite1h: readAnthropicCacheWriteUsage(usage).cacheWrite1h
+	};
+	if (resolved.input !== void 0) target.input = resolved.input;
+	if (resolved.output !== void 0) target.output = resolved.output;
+	if (resolved.cacheRead !== void 0) target.cacheRead = resolved.cacheRead;
+	if (resolved.cacheWrite !== void 0) target.cacheWrite = resolved.cacheWrite;
+	if (resolved.cacheWrite1h !== void 0) target.cacheWrite1h = resolved.cacheWrite1h;
 	target.totalTokens = target.input + target.output + target.cacheRead + target.cacheWrite;
 	const iterationUsage = readLastAnthropicIterationUsage(usage);
 	if (iterationUsage.state === "valid") target.contextUsage = {
@@ -714,4 +707,133 @@ function applyAnthropicMessageDeltaUsage(target, payload, messageStartPromptUsag
 	} else target.contextUsage = { state: "unavailable" };
 }
 //#endregion
-export { applyAnthropicPayloadPolicyToParams as A, usesFoundryBearerAuth as C, canonicalizeBase64 as D, resolveAnthropicImageMediaType as E, resolveAnthropicPayloadPolicy as M, applyAnthropicCacheControlToMessages as O, omitFoundryBearerCredentialHeaders as S, normalizeAnthropicInlineContent as T, CLAUDE_OPUS_FALLBACK_MODEL_COST as _, readAnthropicUsageTokenCount as a, resolveAnthropicFallbackServingModelCost as b, normalizeAnthropicToolChoice as c, resolveOriginalAnthropicToolName as d, toClaudeCodeToolName as f, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as g, ANTHROPIC_SERVER_SIDE_FALLBACKS as h, readAnthropicPromptUsageSnapshot as i, resolveAnthropicEphemeralCacheControl as j, applyAnthropicEphemeralCacheControlMarkers as k, projectAnthropicTools as l, findActiveAnthropicToolTurnAssistantIndex as m, applyAnthropicMessageStartUsage as n, readLastAnthropicIterationUsage as o, ANTHROPIC_OMITTED_REASONING_TEXT as p, readAnthropicCacheWriteUsage as r, normalizeAnthropicToolCallId as s, applyAnthropicMessageDeltaUsage as t, reconcileAnthropicToolChoice as u, applyAnthropicFallbackBoundary as v, createAnthropicInlineImageBudget as w, applyAnthropicRefusal as x, readAnthropicFallbackBoundary as y };
+//#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 hashReplayValue(value) {
+	const normalized = value?.trim();
+	return normalized ? shortHash(normalized) : void 0;
+}
+function buildAnthropicReplayContext(model, options) {
+	return {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		baseUrlHash: hashReplayValue(model.baseUrl),
+		sessionHash: hashReplayValue(options?.sessionId),
+		authProfileHash: hashReplayValue(options?.authProfileId)
+	};
+}
+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 replayContextMatches(state, context) {
+	return state.provider === context.provider && state.api === context.api && state.model === context.model && state.baseUrlHash === context.baseUrlHash && state.sessionHash === context.sessionHash && state.authProfileHash === context.authProfileHash;
+}
+function captureAnthropicCompaction(output, summary, replayIndex, model, options) {
+	const context = buildAnthropicReplayContext(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 = buildAnthropicReplayContext(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 = buildAnthropicReplayContext(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 (replayContextMatches(replayState, context)) return;
+			continue;
+		}
+		if (message.providerReplay?.type !== ANTHROPIC_COMPACTION_REPLAY_TYPE) continue;
+		if (!replayState) return;
+		if (!replayContextMatches(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
+export { resolveAnthropicImageMediaType as A, readAnthropicFallbackBoundary as C, usesFoundryBearerAuth as D, omitFoundryBearerCredentialHeaders as E, resolveAnthropicPayloadPolicy as F, resolveAnthropicServerCompactionPlan as I, applyAnthropicEphemeralCacheControlMarkers as M, applyAnthropicPayloadPolicyToParams as N, createAnthropicInlineImageBudget as O, resolveAnthropicEphemeralCacheControl as P, applyAnthropicFallbackBoundary as S, applyAnthropicRefusal as T, ANTHROPIC_OMITTED_REASONING_TEXT as _, applyAnthropicMessageDeltaUsage as a, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as b, readAnthropicPromptUsageSnapshot as c, normalizeAnthropicToolCallId as d, normalizeAnthropicToolChoice as f, toClaudeCodeToolName as g, resolveOriginalAnthropicToolName as h, suppressAnthropicCompaction as i, applyAnthropicCacheControlToMessages as j, normalizeAnthropicInlineContent as k, readAnthropicUsageTokenCount as l, reconcileAnthropicToolChoice as m, createCompactionCapture as n, applyAnthropicMessageStartUsage as o, projectAnthropicTools as p, isAnthropicReplayRejection as r, readAnthropicCacheWriteUsage as s, buildAnthropicReplayPlan as t, readLastAnthropicIterationUsage as u, findActiveAnthropicToolTurnAssistantIndex as v, resolveAnthropicFallbackServingModelCost as w, CLAUDE_OPUS_FALLBACK_MODEL_COST as x, ANTHROPIC_SERVER_SIDE_FALLBACKS as y };