@openclaw/ai 2026.9.3 → 2026.9.5

package/README.md

@@ -24,7 +24,7 @@ provider plugin hooks, and diagnostics logging) can be injected with
 `configureAiTransportHost`; the defaults are inert.
 
 The explicit `@openclaw/ai/internal/anthropic`, `google-model-family`, `openai`,
-`openai-responses-payload-policy`, `retry-after`, `runtime`, `shared`, and
+`openai-completions-compat`, `openai-responses-payload-policy`, `retry-after`, `runtime`, `shared`, and
 `tool-schema` subpaths exist for the OpenClaw application itself.
 They carry no semver guarantee and can change or disappear in any release; do
 not depend on them outside OpenClaw.

package/dist/{anthropic-CZy5U0NY.mjs → anthropic-COtDvgtt.mjs}

@@ -1,19 +1,18 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { _ as supportsClaudeAdaptiveThinking, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-B2Q_6G8V.mjs";
+import { _ as supportsClaudeAdaptiveThinking, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-DeKjbE8I.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
-import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-CWuF-sS3.mjs";
-import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-CCooe-cr.mjs";
-import { C as applyAnthropicThinkingBindingControls, D as ANTHROPIC_SERVER_SIDE_FALLBACKS, H as resolveAnthropicContextManagementBetaHeader, I as applyAnthropicRequestCacheControl, J as usesFoundryBearerAuth, K as isAnthropicOAuthApiKey, L as buildAnthropicSystemBlocks, N as applyAnthropicContextManagementToRequest, O as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, V as resolveAnthropicCacheOptions, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, l as buildAnthropicGenerationParams, p as isAnthropicReplayRejection, q as omitFoundryBearerCredentialHeaders, t as consumeAnthropicStream, u as convertAnthropicMessages, z as isDirectAnthropicModel } from "./anthropic-stream-reducer-B_yo_7pf.mjs";
+import { E as resolveAnthropicThinkingEffort, O as usesClaudeFable5MessagesContract, T as requiresClaudeAdaptiveThinking, b as ANTHROPIC_CLAUDE_CODE_VERSION, k as usesClaudeStreamingRefusalContract, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels, w as prepareClaudeNoPrefillRequestContext, x as applyClaudeRequestContract } from "./host-B4MeUNBc.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-1cyq5Y7x.mjs";
+import { C as applyAnthropicThinkingBindingControls, D as ANTHROPIC_SERVER_SIDE_FALLBACKS, H as resolveAnthropicContextManagementBetaHeader, I as applyAnthropicRequestCacheControl, J as usesFoundryBearerAuth, K as isAnthropicOAuthApiKey, L as buildAnthropicSystemBlocks, N as applyAnthropicContextManagementToRequest, O as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, V as resolveAnthropicCacheOptions, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, l as buildAnthropicGenerationParams, p as isAnthropicReplayRejection, q as omitFoundryBearerCredentialHeaders, t as consumeAnthropicStream, u as convertAnthropicMessages, z as isDirectAnthropicModel } from "./anthropic-stream-reducer-BvdYYWL8.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { n as buildBaseOptions, r as clampMaxTokensToModel, t as adjustMaxTokensForThinking } from "./simple-options-tcKOqnpF.mjs";
+import { n as buildBaseOptions, r as clampMaxTokensToModel, t as adjustMaxTokensForThinking } from "./simple-options-C6cFWj_f.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { c as finalizeTransportStream, f as notifyProviderHttpResponse, t as assignTransportErrorDetails } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { T as parseJsonWithRepair, l as finalizeTransportStream, n as assignTransportErrorDetails, p as notifyProviderHttpResponse } from "./transport-stream-shared-D-6FQSHm.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as parseJsonWithRepair } from "./json-parse-Dw_hnxsA.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { t as createAssistantOutput } from "./assistant-output-iqnlJCV2.mjs";
-import { t as resolveOpencodeSessionHeaders } from "./session-affinity-CCH7eYdB.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-pPmUIwKt.mjs";
+import { t as createAssistantOutput } from "./assistant-output-BsEkB-vU.mjs";
+import { n as resolveOpencodeSessionHeaders } from "./session-affinity-Bcunsn4I.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-BsRAhuWJ.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
 import Anthropic from "@anthropic-ai/sdk";
 import { Stream } from "@anthropic-ai/sdk/core/streaming.js";
@@ -107,7 +106,7 @@ const streamAnthropic = (model, context, options) => {
 				...requestOptions?.signal ? { signal: requestOptions.signal } : {},
 				...requestOptions?.timeoutMs !== void 0 ? { timeout: requestOptions.timeoutMs } : {},
 				maxRetries: 0,
-				headers: applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader !== void 0 ? { "anthropic-beta": betaHeader } : void 0)
+				headers: applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader ? { "anthropic-beta": betaHeader } : void 0)
 			};
 			const response = await client.messages.create({
 				...params,
@@ -191,8 +190,7 @@ const streamSimpleAnthropic = (model, context, options) => {
 	});
 	if (!reasoning) return streamAnthropic(model, context, {
 		...base,
-		thinkingEnabled: mandatoryAdaptiveThinking,
-		...mandatoryAdaptiveThinking ? { effort: "high" } : {}
+		thinkingEnabled: mandatoryAdaptiveThinking
 	});
 	if (supportsClaudeAdaptiveThinking(model)) {
 		const effort = resolveAnthropicThinkingEffort(model, reasoning);
@@ -202,7 +200,7 @@ const streamSimpleAnthropic = (model, context, options) => {
 			effort
 		});
 	}
-	const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, reasoning, options?.thinkingBudgets);
+	const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens ?? base.maxTokens, reasoning, options?.thinkingBudgets);
 	const thinkingEnabled = adjusted.thinkingBudget >= ANTHROPIC_MIN_THINKING_BUDGET_TOKENS;
 	const maxTokens = thinkingEnabled ? adjusted.maxTokens : clampMaxTokensToModel(model, options?.maxTokens ?? model.maxTokens);
 	return streamAnthropic(model, context, {
@@ -342,13 +340,15 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 		authProfileId: options?.authProfileId,
 		sessionId: options?.sessionId
 	});
+	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
 	const params = {
 		model: model.id,
 		messages: await convertAnthropicMessages(transformProviderMessages(replayPlan.messages, model, normalizeAnthropicToolCallId), model, isOAuthTokenResult, {
 			profile: "provider",
 			allowEmptySignature: compat.allowEmptySignature,
 			compaction: replayPlan.compaction,
-			replayThinkingEnabled
+			replayThinkingEnabled,
+			cacheBreakpointOptOutMessageIndexes
 		}),
 		max_tokens: options?.maxTokens ?? model.maxTokens,
 		stream: true
@@ -362,7 +362,7 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 		toolProjection,
 		profile: "provider"
 	}));
-	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools);
+	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools, cacheBreakpointOptOutMessageIndexes);
 	return {
 		params,
 		toolProjection,

package/dist/{anthropic-payload-policy-wuRCb6MH.d.mts → anthropic-payload-policy-5Erq1Nzy.d.mts}

@@ -1,6 +1,6 @@
-import "./index-CQ6LTHw8.mjs";
-import { D as Model } from "./types-Dy1q0CSu.mjs";
-import { t as AnthropicContextManagementOptions } from "./provider-options-BXr9Ec83.mjs";
+import "./index-DaF2QbwS.mjs";
+import { O as Model } from "./types-4_uVs5WH.mjs";
+import { t as AnthropicContextManagementOptions } from "./provider-options-DprLsWh9.mjs";
 import { TextBlockParam } from "@anthropic-ai/sdk/resources/messages.js";
 //#region packages/ai/src/transports/anthropic-payload-policy.d.ts
 /** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */

package/dist/{anthropic-stream-reducer-B_yo_7pf.mjs → anthropic-stream-reducer-BvdYYWL8.mjs}

@@ -1,19 +1,18 @@
-import { _ as supportsClaudeAdaptiveThinking, b as supportsClaudeNativeXhighEffort, d as resolveClaudeModelIdentity, m as resolveClaudeOpus5ModelIdentity, u as resolveClaudeFable5ModelIdentity } from "./src-B2Q_6G8V.mjs";
+import { _ as supportsClaudeAdaptiveThinking, b as supportsClaudeNativeXhighEffort, d as resolveClaudeModelIdentity, m as resolveClaudeOpus5ModelIdentity, s as bindsClaudeThinkingPrefix, u as resolveClaudeFable5ModelIdentity } from "./src-DeKjbE8I.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 { C as mapAnthropicStopReason, E as resolveAnthropicThinkingEffort, T as requiresClaudeAdaptiveThinking, _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, j as calculateCost, m as extractToolResultText, n as getAiTransportHost, p as extractToolResultBlockText, v as sanitizeSurrogates, y as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK } from "./host-B4MeUNBc.mjs";
+import { i as asNonNegativeFiniteNumber, n as estimateBase64DecodedBytes } from "./base64-BQOzsvUH.mjs";
+import "./transport-utils-1cyq5Y7x.mjs";
+import { a as resolveProviderRequestCapabilities, i as resolveProviderEndpoint } from "./host-policy-DUnXSx0I.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.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 { f as splitSystemPromptCacheBoundary, h as stripSystemPromptRelocatableBoundary, m as stripSystemPromptCacheBoundary, v as sortPromptCacheToolsByName } from "./simple-options-C6cFWj_f.mjs";
+import { t as parsePositiveInteger } from "./positive-integer-DtjCkbue.mjs";
+import { n as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-CD9c_fK8.mjs";
+import { E as parseStreamingJson, _ as sanitizeTransportPayloadText, c as finalizeTerminalToolCallArguments, g as sanitizeNonEmptyTransportPayloadText, r as coerceTransportToolCallArguments, v as transportAbortError, w as createToolArgumentPreviewSchedule, x as parseJsonObjectPreservingUnsafeIntegers } from "./transport-stream-shared-D-6FQSHm.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CnUSOwhr.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. */
@@ -148,11 +147,14 @@ function applyAnthropicCacheControlToSystem(system, cacheControl) {
 			continue;
 		}
 		const record = block;
-		if (record.type !== "text" || typeof record.text !== "string") {
+		const blockText = record.text;
+		if (record.type !== "text" || typeof blockText !== "string") {
 			normalizedBlocks.push(block);
 			continue;
 		}
-		const split = splitSystemPromptCacheBoundary(record.text);
+		const text = stripSystemPromptRelocatableBoundary(blockText);
+		record.text = text;
+		const split = splitSystemPromptCacheBoundary(text);
 		if (!split) {
 			if (record.cache_control === void 0) record.cache_control = cacheControl;
 			normalizedBlocks.push(record);
@@ -547,39 +549,34 @@ const schemaMapKeywords = /* @__PURE__ */ new Set([
 	"patternProperties",
 	"properties"
 ]);
+/** Normalize the detached JSON projection and report tuple changes to enclosing schemas. */
 function normalizeAnthropicJsonSchema(schema) {
-	if (!isRecord(schema)) return schema;
+	if (!isRecord(schema)) return false;
 	let changed = false;
-	const normalized = { ...schema };
 	for (const [key, value] of Object.entries(schema)) {
 		if (schemaValueKeywords.has(key) && !Array.isArray(value)) {
-			const next = normalizeAnthropicJsonSchema(value);
-			normalized[key] = next;
-			changed ||= next !== value;
+			changed = normalizeAnthropicJsonSchema(value) || changed;
 			continue;
 		}
 		if (schemaArrayKeywords.has(key) && Array.isArray(value)) {
-			const next = value.map(normalizeAnthropicJsonSchema);
-			normalized[key] = next;
-			changed ||= next.some((entry, index) => entry !== value[index]);
+			for (const entry of value) changed = normalizeAnthropicJsonSchema(entry) || changed;
 			continue;
 		}
-		if (schemaMapKeywords.has(key) && isRecord(value)) {
-			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, normalizeAnthropicJsonSchema(entryValue)]));
-			normalized[key] = next;
-			changed ||= Object.entries(value).some(([entryKey, entryValue]) => next[entryKey] !== entryValue);
-		}
+		if (schemaMapKeywords.has(key) && isRecord(value)) for (const entry of Object.values(value)) changed = normalizeAnthropicJsonSchema(entry) || changed;
 	}
 	if (Array.isArray(schema.items)) {
-		normalized.prefixItems = schema.items.map(normalizeAnthropicJsonSchema);
+		for (const entry of schema.items) normalizeAnthropicJsonSchema(entry);
+		schema.prefixItems = schema.items;
 		const additionalItems = schema.additionalItems;
-		if (typeof additionalItems === "boolean" || isRecord(additionalItems)) normalized.items = normalizeAnthropicJsonSchema(additionalItems);
-		else delete normalized.items;
-		delete normalized.additionalItems;
+		if (typeof additionalItems === "boolean" || isRecord(additionalItems)) {
+			normalizeAnthropicJsonSchema(additionalItems);
+			schema.items = additionalItems;
+		} else delete schema.items;
+		delete schema.additionalItems;
 		changed = true;
 	}
-	if (changed) delete normalized.$schema;
-	return changed ? normalized : schema;
+	if (changed) delete schema.$schema;
+	return changed;
 }
 /** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
 function projectAnthropicTools(tools, toWireName) {
@@ -598,11 +595,8 @@ function projectAnthropicTools(tools, toWireName) {
 				unavailableOriginalNames.add(name);
 				continue;
 			}
-			const anthropicSchema = normalizeAnthropicJsonSchema(schemaProjection.schema);
-			if (!isRecord(anthropicSchema)) {
-				unavailableOriginalNames.add(name);
-				continue;
-			}
+			const anthropicSchema = schemaProjection.schema;
+			normalizeAnthropicJsonSchema(anthropicSchema);
 			const properties = anthropicSchema.properties;
 			const required = anthropicSchema.required;
 			if (properties !== void 0 && properties !== null && !isRecord(properties) || required !== void 0 && required !== null && (!Array.isArray(required) || required.some((entry) => typeof entry !== "string"))) {
@@ -680,21 +674,23 @@ function createCompactionCapture(output, model, options) {
 			const content = typeof block.content === "string" ? block.content : "";
 			pending.set(index, {
 				content,
-				replayIndex
+				replayIndex,
+				...typeof block.encrypted_content === "string" || block.encrypted_content === null ? { encryptedContent: block.encrypted_content } : {}
 			});
 			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;
+			if (typeof delta.content === "string") capture.content += delta.content;
+			if (typeof delta.encrypted_content === "string" || delta.encrypted_content === null) capture.encryptedContent = delta.encrypted_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);
+			captureAnthropicCompaction(output, capture, model, options);
 			return true;
 		}
 	};
@@ -702,18 +698,20 @@ function createCompactionCapture(output, model, options) {
 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);
+	return state.type === ANTHROPIC_COMPACTION_REPLAY_TYPE && state.data.length > 0 && (state.encryptedContent === void 0 || state.encryptedContent === null || typeof state.encryptedContent === "string") && (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) {
+function captureAnthropicCompaction(output, capture, model, options) {
+	const { content: summary, replayIndex, encryptedContent } = capture;
 	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,
+		...encryptedContent !== void 0 ? { encryptedContent } : {},
 		replayIndex,
 		...context,
 		baseUrlHash: context.baseUrlHash
@@ -746,7 +744,8 @@ function resolveNewestAnthropicCompaction(messages, model, options) {
 		return {
 			owner: message,
 			replayIndex: replayState.replayIndex ?? 0,
-			summary: replayState.data
+			summary: replayState.data,
+			...replayState.encryptedContent !== void 0 ? { encryptedContent: replayState.encryptedContent } : {}
 		};
 	}
 }
@@ -762,7 +761,8 @@ function buildAnthropicReplayPlan(messages, model, options) {
 		}, ...messages.slice(ownerIndex + 1)],
 		compaction: {
 			type: "compaction",
-			content: checkpoint.summary
+			content: checkpoint.summary,
+			...checkpoint.encryptedContent !== void 0 ? { encrypted_content: checkpoint.encryptedContent } : {}
 		}
 	};
 }
@@ -772,12 +772,13 @@ function isAnthropicReplayRejection(error) {
 	const record = error;
 	const nested = record.error && typeof record.error === "object" && !Array.isArray(record.error) ? record.error : void 0;
 	const text = [
+		record.errorMessage,
 		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"));
+	return (record.status === 400 || record.errorCode === "400" || text.startsWith("http 400:")) && (text.includes("compaction") || text.includes("context_management"));
 }
 //#endregion
 //#region packages/ai/src/internal/anthropic-inline-images.ts
@@ -856,6 +857,7 @@ async function convertContentBlocks(content, model, imageBudget, profile, isErro
 }
 async function convertAnthropicMessages(transformedMessages, model, isOAuthToken, options) {
 	const params = [];
+	const retainRuntimeContext = bindsClaudeThinkingPrefix(model);
 	const imageBudget = createAnthropicInlineImageBudget();
 	const allowReasoningContentReplay = options.allowReasoningContentReplay === true;
 	const replayThinkingEnabled = options.replayThinkingEnabled !== false;
@@ -867,6 +869,7 @@ async function convertAnthropicMessages(transformedMessages, model, isOAuthToken
 		if (msg.role === "user") {
 			if (typeof msg.content === "string") {
 				if (msg.content.trim().length > 0) {
+					if (msg.runtimeContextCarrier && !retainRuntimeContext) options.cacheBreakpointOptOutMessageIndexes?.add(params.length);
 					const userParam = {
 						role: "user",
 						content: sanitizeTransportPayloadText(msg.content)
@@ -892,6 +895,7 @@ async function convertAnthropicMessages(transformedMessages, model, isOAuthToken
 			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;
+			if (msg.runtimeContextCarrier && !retainRuntimeContext) options.cacheBreakpointOptOutMessageIndexes?.add(params.length);
 			const userParam = {
 				role: "user",
 				content: filteredBlocks
@@ -1017,7 +1021,7 @@ function buildAnthropicGenerationParams({ model, options, tools, toolProjection,
 					type: "adaptive",
 					display
 				};
-				const effort = options?.effort ?? (mandatoryAdaptiveThinking ? "high" : void 0);
+				const effort = options?.effort ?? (mandatoryAdaptiveThinking ? resolveAnthropicThinkingEffort(model, void 0) : void 0);
 				if (effort) params.output_config = { effort };
 			} else params.thinking = {
 				type: "enabled",
@@ -1238,7 +1242,9 @@ async function consumeAnthropicStream(params) {
 		const allowReasoningContentReplay = managed && resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
 		const reasoningContentThinkingBlocks = /* @__PURE__ */ new Map();
 		const reasoningContentTextBlocks = /* @__PURE__ */ new Map();
+		let sawMessageStart = false;
 		let sawMessageStop = false;
+		let sawStopReason = false;
 		const pendingTextEnds = [];
 		const flushPendingTextEnds = () => {
 			for (const event of pendingTextEnds) eventSink.push(event);
@@ -1346,6 +1352,7 @@ async function consumeAnthropicStream(params) {
 				throw new Error(readStringField(error, "message") || "Anthropic Messages stream failed");
 			}
 			if (event.type === "message_start") {
+				sawMessageStart = true;
 				const message = asOptionalObjectRecord(event.message);
 				const usage = asRecord(message?.usage);
 				output.responseId = typeof message?.id === "string" ? message.id : void 0;
@@ -1635,6 +1642,7 @@ async function consumeAnthropicStream(params) {
 				const delta = asOptionalObjectRecord(event.delta);
 				const usage = asOptionalObjectRecord(event.usage);
 				if (typeof delta?.stop_reason === "string" && delta.stop_reason) {
+					sawStopReason = true;
 					if (delta.stop_reason === "refusal") applyAnthropicRefusal(output, delta.stop_details, model.provider);
 					else output.stopReason = mapAnthropicStopReason(delta.stop_reason);
 				}
@@ -1648,7 +1656,8 @@ async function consumeAnthropicStream(params) {
 		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));
+		if ((sawMessageStart || blocks.length > 0) && !sawMessageStop && !sawStopReason) throw new Error("Anthropic stream ended before a terminal event");
+		finalizeTerminalToolCallArguments(sealedToolCalls.map(({ block }) => block), (block) => block.partialJson && block.partialJson.length > 0 ? block.partialJson : seededToolArguments.get(block), void 0, { repairStringLiterals: true });
 		for (const sealed of sealedToolCalls) {
 			delete sealed.block.partialJson;
 			eventSink.push({

package/dist/{api-registry-CB1-1oQ2.d.mts → api-registry-Ba2Cv-ut.d.mts}

@@ -1,5 +1,5 @@
-import "./index-CQ6LTHw8.mjs";
-import { D as Model, J as StreamOptions, W as SimpleStreamOptions, d as Context, n as Api, q as StreamFunction, s as AssistantMessageEventStreamContract } from "./types-Dy1q0CSu.mjs";
+import "./index-DaF2QbwS.mjs";
+import { G as SimpleStreamOptions, J as StreamFunction, O as Model, Y as StreamOptions, d as Context, n as Api, s as AssistantMessageEventStreamContract } from "./types-4_uVs5WH.mjs";
 //#region packages/ai/src/api-registry.d.ts
 /** Runtime stream adapter signature stored in the API provider registry. */
 type ApiStreamFunction = (model: Model, context: Context, options?: StreamOptions) => AssistantMessageEventStreamContract;

package/dist/{assistant-output-iqnlJCV2.mjs → assistant-output-BsEkB-vU.mjs}

@@ -1,4 +1,4 @@
-import { i as createEmptyTransportUsage } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { a as createEmptyTransportUsage } from "./transport-stream-shared-D-6FQSHm.mjs";
 //#region packages/ai/src/transports/assistant-output.ts
 function createAssistantOutput(model, api = model.api) {
 	return {

package/dist/{azure-openai-responses-Crpa40QR.mjs → azure-openai-responses-YrgnD583.mjs}

@@ -1,9 +1,10 @@
 import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
-import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-BI0rkM-5.mjs";
-import { n as buildBaseOptions } from "./simple-options-tcKOqnpF.mjs";
+import { n as getAiTransportHost } from "./host-B4MeUNBc.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-1wfaIszn.mjs";
+import { n as buildBaseOptions } from "./simple-options-C6cFWj_f.mjs";
+import { g as resolveOpenAISimpleReasoningEffort } from "./openai-transport-params-DQeuAvBl.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-ZyQEzS5i.mjs";
+import { a as runResponsesStreamLifecycle, i as createResponsesAssistantOutput, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-CwsziD_m.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
 import OpenAI, { AzureOpenAI } from "openai";
 //#region packages/ai/src/providers/azure-openai-responses.ts
@@ -20,9 +21,6 @@ function resolveDeploymentName(model, options) {
 		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
 	});
 }
-/**
-* Generate function for Azure OpenAI Responses API
-*/
 const streamAzureOpenAIResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	const output = createResponsesAssistantOutput(model, "azure-openai-responses");
@@ -50,11 +48,10 @@ const streamSimpleAzureOpenAIResponses = (model, context, options) => {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const base = buildBaseOptions(model, options, apiKey);
 	const authProfileId = options?.authProfileId;
-	const reasoningEffort = resolveResponsesReasoningEffort(model, options?.reasoning);
 	return streamAzureOpenAIResponses(model, context, {
 		...base,
 		authProfileId,
-		reasoningEffort: reasoningEffort === "max" ? "xhigh" : reasoningEffort
+		reasoningEffort: resolveOpenAISimpleReasoningEffort(model, options?.reasoning)
 	});
 };
 function normalizeAzureBaseUrl(baseUrl) {

package/dist/{base64-D-su8YVo.mjs → base64-BQOzsvUH.mjs}

@@ -45,10 +45,10 @@ function parseStrictPositiveInteger(value) {
 //#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;
+	let effectiveLen = base64.length;
+	const firstWhitespace = base64.search(/[\x00-\x20]/);
+	if (firstWhitespace !== -1) {
+		for (let i = firstWhitespace; i < base64.length; i += 1) if (base64.charCodeAt(i) <= 32) effectiveLen -= 1;
 	}
 	if (effectiveLen === 0) return 0;
 	let padding = 0;

package/dist/credential-redaction-BKv49aiv.d.mts

@@ -0,0 +1,24 @@
+//#region packages/ai/src/utils/credential-redaction.d.ts
+type DiagnosticMediaField = {
+  kind: "context";
+} | {
+  kind: "redacted";
+  bytes?: number;
+  source?: string | Uint8Array;
+};
+type DiagnosticProjectionPolicy = {
+  omitField?: (key: string) => boolean;
+  propertyScope?: "enumerable" | "error";
+  projectBinary?: (binary: Uint8Array) => unknown;
+  projectMedia?: (key: string, media: Extract<DiagnosticMediaField, {
+    kind: "redacted";
+  }>) => Record<string, unknown>;
+};
+/** Fresh records need no native-object probe while their prototype stays ordinary. */
+declare function createDiagnosticRecord(): Record<string, unknown>;
+declare function projectDiagnosticValue(value: unknown, policy?: DiagnosticProjectionPolicy, seen?: WeakSet<object>, mediaPayload?: boolean, state?: {
+  changed: boolean;
+  nodesRemaining: number;
+}): unknown;
+//#endregion
+export { createDiagnosticRecord as n, projectDiagnosticValue as r, DiagnosticProjectionPolicy as t };

package/dist/{diagnostics-dV98PqIy.mjs → diagnostics-Dm4bisWG.mjs}

@@ -1,5 +1,7 @@
+import { a as isProviderRefusalAssistantError } from "./diagnostics-CPeq9F7y.mjs";
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import "./provider-error-C6TbKiey.mjs";
+import "./provider-error-DDqw9Qda.mjs";
+import { r as asFiniteNumber } from "./base64-BQOzsvUH.mjs";
 //#region packages/normalization-core/src/error-coercion.ts
 function readProperty(value, key) {
 	try {
@@ -59,6 +61,7 @@ function collectNestedErrorCandidates(err) {
 			readProperty(current, "reason"),
 			readProperty(current, "original"),
 			readProperty(current, "error"),
+			readProperty(current, "suppressed"),
 			readProperty(current, "data")
 		];
 		const errors = readProperty(current, "errors");
@@ -67,6 +70,90 @@ function collectNestedErrorCandidates(err) {
 	});
 }
 //#endregion
+//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
+/**
+* Canonical mapping for terminal OpenAI Responses events.
+*
+* `response.completed`, `response.incomplete`, and `response.failed` are terminal and can carry
+* usage, so every Responses path finalizes through the helpers here. Keeping one owner prevents
+* package and managed transports from drifting on token buckets, service-tier pricing, or future
+* terminal-event semantics.
+*/
+/** A known output ceiling can resume sampling after admitted tools have settled. */
+function isResponsesOutputLimitToolCallError(message) {
+	return message.stopReason === "error" && message.errorCode === "incomplete_tool_call" && !isProviderRefusalAssistantError(message) && message.diagnostics?.some(({ type, details }) => type === "openai_responses_terminal" && details?.eventType === "response.incomplete" && details.incompleteReason === "max_output_tokens") === true;
+}
+function readReportedCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function readCount(value) {
+	return readReportedCount(value) ?? 0;
+}
+/**
+* Split a terminal usage payload into the priced buckets.
+*
+* OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
+* billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
+* split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
+* whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
+* short of what the buckets actually price.
+*/
+function mapResponsesTerminalUsage(usage) {
+	if (!usage) return;
+	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
+	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
+	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
+	const output = readCount(usage.output_tokens);
+	const bucketTotal = input + output + cacheRead + cacheWrite;
+	const totalTokens = Math.max(bucketTotal, readCount(usage.total_tokens));
+	const reportedInput = readReportedCount(usage.input_tokens);
+	const reportedOutput = readReportedCount(usage.output_tokens);
+	const reportedTotal = readReportedCount(usage.total_tokens);
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		contextUsage: reportedInput !== void 0 && (reportedOutput !== void 0 || reportedTotal !== void 0 && reportedTotal >= reportedInput) && cacheRead + cacheWrite <= reportedInput ? {
+			state: "available",
+			promptTokens: reportedInput,
+			totalTokens: Math.max(totalTokens, reportedInput + (reportedOutput ?? 0))
+		} : { state: "unavailable" },
+		totalTokens
+	};
+}
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+function readResponsesReasoningTokens(usage) {
+	return asFiniteNumber(usage?.output_tokens_details?.reasoning_tokens);
+}
+function mapResponsesTerminalStopReason(status) {
+	if (!status) return "stop";
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed":
+		case "cancelled": return "error";
+		case "in_progress":
+		case "queued": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
+	}
+}
+/**
+* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+* content-filtered turn is a provider error rather than a truncated answer, and a turn that
+* produced tool calls reports `toolUse` instead of a plain stop.
+*/
+function resolveResponsesTerminalStopReason(params) {
+	const status = params.status ?? (params.terminalEventType === "response.incomplete" ? "incomplete" : void 0);
+	if (status === "incomplete" && params.incompleteReason === "content_filter") return {
+		stopReason: "error",
+		errorMessage: "Provider incomplete_reason: content_filter"
+	};
+	const stopReason = mapResponsesTerminalStopReason(status);
+	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
+	return { stopReason };
+}
+//#endregion
 //#region packages/ai/src/utils/retryable-network-errors.ts
 const WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE = "ERR_WEBSOCKET_NON_RETRYABLE_CLOSE";
 const TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
@@ -208,4 +295,4 @@ function formatModelTransportDebugBaseUrl(rawUrl) {
 	return rawUrl ? formatModelTransportDebugUrl(rawUrl) : "default";
 }
 //#endregion
-export { resolveModelSseDebugMode as a, isTransientNetworkError as c, resolveModelPayloadDebugMode as i, extractErrorCodeOrErrno as l, formatModelTransportDebugUrl as n, WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE as o, emitModelTransportDebug as r, hasRetryableConnectionErrorCode as s, formatModelTransportDebugBaseUrl as t, toErrorObject as u };
+export { resolveModelSseDebugMode as a, isTransientNetworkError as c, readResponsesReasoningTokens as d, resolveResponsesTerminalStopReason as f, resolveModelPayloadDebugMode as i, isResponsesOutputLimitToolCallError as l, toErrorObject as m, formatModelTransportDebugUrl as n, WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE as o, extractErrorCodeOrErrno as p, emitModelTransportDebug as r, hasRetryableConnectionErrorCode as s, formatModelTransportDebugBaseUrl as t, mapResponsesTerminalUsage as u };

package/dist/diagnostics.d.mts

@@ -1,31 +1,12 @@
-import { a as extractDiagnosticError, i as createAssistantMessageDiagnostic, n as DiagnosticErrorInfo, o as formatThrownValue, r as appendAssistantMessageDiagnostic, s as isProviderRefusalAssistantError, t as AssistantMessageDiagnostic } from "./diagnostics-DnPnOui6.mjs";
+import { dt as DiagnosticErrorInfo, ft as appendAssistantMessageDiagnostic, gt as isProviderRefusalAssistantError, ht as formatThrownValue, mt as extractDiagnosticError, pt as createAssistantMessageDiagnostic, ut as AssistantMessageDiagnostic } from "./types-4_uVs5WH.mjs";
+import { n as isResponsesOutputLimitToolCallError } from "./openai-responses-terminal-usage-Dl3J6zrf.mjs";
 import { n as ProviderErrorRedactor, r as configureProviderErrorRedactor } from "./provider-error-CzNw4BWX.mjs";
+import { r as projectDiagnosticValue, t as DiagnosticProjectionPolicy } from "./credential-redaction-BKv49aiv.mjs";
 import { n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./model-transport-url-DKocrEsb.mjs";
-//#region packages/ai/src/utils/credential-redaction.d.ts
-type DiagnosticMediaField = {
-  kind: "context";
-} | {
-  kind: "redacted";
-  bytes?: number;
-  source?: string | Uint8Array;
-};
-type DiagnosticProjectionPolicy = {
-  omitField?: (key: string) => boolean;
-  propertyScope?: "enumerable" | "error";
-  projectBinary?: (binary: Uint8Array) => unknown;
-  projectMedia?: (key: string, media: Extract<DiagnosticMediaField, {
-    kind: "redacted";
-  }>) => Record<string, unknown>;
-};
-export declare function projectDiagnosticValue(value: unknown, policy?: DiagnosticProjectionPolicy, seen?: WeakSet<object>, mediaPayload?: boolean, state?: {
-  changed: boolean;
-  nodesRemaining: number;
-}): unknown;
-//#endregion
 //#region packages/ai/src/utils/retryable-network-errors.d.ts
 export declare const WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE = "ERR_WEBSOCKET_NON_RETRYABLE_CLOSE";
 export declare function hasRetryableConnectionErrorCode(message: string): boolean;
 /** Returns true when any nested error proves a transient network failure. */
 export declare function isTransientNetworkError(err: unknown): boolean;
 //#endregion
-export { AssistantMessageDiagnostic, DiagnosticErrorInfo, type DiagnosticProjectionPolicy, type ProviderErrorRedactor, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, emitModelTransportDebug, extractDiagnosticError, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, formatThrownValue, isProviderRefusalAssistantError };
+export { AssistantMessageDiagnostic, DiagnosticErrorInfo, type DiagnosticProjectionPolicy, type ProviderErrorRedactor, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, emitModelTransportDebug, extractDiagnosticError, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, formatThrownValue, isProviderRefusalAssistantError, isResponsesOutputLimitToolCallError, projectDiagnosticValue };