@openclaw/ai 2026.9.3 → 2026.9.5

package/dist/transports.mjs

@@ -1,34 +1,34 @@
-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 { n as normalizeLowercaseStringOrEmpty, t as hasNonEmptyString } from "./string-coerce-fsri9iCu.mjs";
-import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, h as defaultsClaudeAdaptiveThinking, 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 { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { i as stableStringify } from "./provider-error-C6TbKiey.mjs";
-import { a as isNativeOpenAIEndpoint, c as resolveOpenAIPromptCacheKeySupport, i as detectOpenAICompletionsCompat, l as usesNativeOpenAICodexResponsesBackend, o as isOpenAICodexResponsesModel, r as resolveOpenAIPromptCacheParams, s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-BI0rkM-5.mjs";
-import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl, u as toErrorObject } from "./diagnostics-dV98PqIy.mjs";
-import "./base64-D-su8YVo.mjs";
-import { c as resolveModelHeaderSentinels$1, i as isCodeModeModelVisibleToolName, n as createAbortError$1, o as readResponseTextSnippet, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-CCooe-cr.mjs";
-import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { i as resolveProviderEndpoint, r as resolveOpenAIStrictToolSetting, s as transformTransportMessages, t as buildGuardedModelFetch } from "./host-policy-CAopLRKA.mjs";
-import { B as logAnthropicContextEdits, C as applyAnthropicThinkingBindingControls, D as ANTHROPIC_SERVER_SIDE_FALLBACKS, F as applyAnthropicPayloadPolicyToParams, G as resolveAnthropicServerCompactionPlan, 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, P as applyAnthropicEphemeralCacheControlMarkers, R as isAnthropicServerToolClearingEnabled, U as resolveAnthropicEphemeralCacheControl, V as resolveAnthropicCacheOptions, W as resolveAnthropicPayloadPolicy, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, l as buildAnthropicGenerationParams, m as resolveNewestAnthropicCompaction, 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, S as defaultsClaudeAdaptiveThinking, 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 truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { a as redactDiagnosticText, o as stableStringify } from "./provider-error-DDqw9Qda.mjs";
+import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, m as toErrorObject, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./diagnostics-Dm4bisWG.mjs";
+import { a as readResponseTextSnippet, i as isCodeModeModelVisibleToolName, n as createAbortError$1, s as resolveModelHeaderSentinels, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-1cyq5Y7x.mjs";
+import { a as resolveOpenAIPromptCacheKeySupport, i as resolveOpenAICompletionsCompat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-CkwdxTZx.mjs";
+import { i as resolveProviderEndpoint, s as transformTransportMessages, t as buildGuardedModelFetch } from "./host-policy-DUnXSx0I.mjs";
+import { B as logAnthropicContextEdits, C as applyAnthropicThinkingBindingControls, D as ANTHROPIC_SERVER_SIDE_FALLBACKS, F as applyAnthropicPayloadPolicyToParams, G as resolveAnthropicServerCompactionPlan, 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, P as applyAnthropicEphemeralCacheControlMarkers, R as isAnthropicServerToolClearingEnabled, U as resolveAnthropicEphemeralCacheControl, V as resolveAnthropicCacheOptions, W as resolveAnthropicPayloadPolicy, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, l as buildAnthropicGenerationParams, m as resolveNewestAnthropicCompaction, 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 { a as codeModeToolSurfaceObserver, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking } from "./simple-options-tcKOqnpF.mjs";
-import { C as readOpenAICompletionsContentDeltas, D as throwIfModelStreamAborted, E as resolvePromptCacheKey, O as redactIdentifier, S as parseOpenAICompletionsUsage, T as resolveOpenAIClientBaseUrl, _ as createOpenAIProviderAcceptanceHook, a as enforceCodeModeResponsesToolSurface, b as log, c as readCodeModePayloadToolName, d as resolveOpenAIReasoningEffortMap, f as projectOpenAITools, g as createModelStreamCooperativeScheduler, h as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, i as buildOpenAISdkRequestOptions, k as sha256Hex, l as resolveCodeModeResponsesVisibleToolNames, m as reconcileOpenAIResponsesToolChoice, n as buildOpenAIClientHeaders, o as filterCodeModePayloadTools, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as createOpenAIResponseHook, w as readOpenAICompletionsReasoningBatch, x as measureUtf8AppendBytes, y as isOpenAICompletionsThinkingEnabled } from "./openai-transport-params-DNasp2fU.mjs";
+import { a as codeModeToolSurfaceObserver, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking, v as sortPromptCacheToolsByName } from "./simple-options-C6cFWj_f.mjs";
+import { A as resolvePromptCacheKey, C as isOpenAICompletionsThinkingEnabled, D as readOpenAICompletionsContentDeltas, E as parseOpenAICompletionsUsage, M as redactIdentifier, N as sha256Hex, O as readOpenAICompletionsReasoningBatch, S as createResponseModelTracker, T as measureUtf8AppendBytes, _ as resolveOpenAIReasoningEffortMap, a as enforceCodeModeResponsesToolSurface, b as createOpenAIProviderAcceptanceHook, c as readCodeModePayloadToolName, i as buildOpenAISdkRequestOptions, j as throwIfModelStreamAborted, k as resolveOpenAIClientBaseUrl, l as resolveCodeModeResponsesVisibleToolNames, n as buildOpenAIClientHeaders, o as filterCodeModePayloadTools, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as log, x as createOpenAIResponseHook, y as createModelStreamCooperativeScheduler } from "./openai-transport-params-DQeuAvBl.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { S as quoteUnsafeIntegerLiterals, _ as transportAbortError, a as createWritableTransportEventStream, b as parseJsonObjectPreservingUnsafeIntegers, c as finalizeTransportStream, d as notifyProviderHttpMetadata, f as notifyProviderHttpResponse, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, i as createEmptyTransportUsage, l as mergeTransportHeaders, m as parseTerminalToolCallArguments, n as coerceTransportToolCallArguments, o as failTransportStream, p as notifyProviderStreamOpened, r as copyProviderAcceptanceObserver, s as finalizeTerminalToolCallArguments, t as assignTransportErrorDetails, u as mergeTransportMetadata, v as withProviderAcceptanceObserver, x as parseJsonPreservingUnsafeIntegers, y as withProviderResponseHook } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { C as quoteUnsafeIntegerLiterals, S as parseJsonPreservingUnsafeIntegers, _ as sanitizeTransportPayloadText, a as createEmptyTransportUsage, b as withProviderResponseHook, c as finalizeTerminalToolCallArguments, d as mergeTransportMetadata, f as notifyProviderHttpMetadata, g as sanitizeNonEmptyTransportPayloadText, h as parseTerminalToolCallArguments, i as copyProviderAcceptanceObserver, l as finalizeTransportStream, m as notifyProviderStreamOpened, n as assignTransportErrorDetails, o as createWritableTransportEventStream, p as notifyProviderHttpResponse, r as coerceTransportToolCallArguments, s as failTransportStream, t as IncompleteToolCallError, u as mergeTransportHeaders, v as transportAbortError, x as parseJsonObjectPreservingUnsafeIntegers, y as withProviderAcceptanceObserver } from "./transport-stream-shared-D-6FQSHm.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-BuSUaAk5.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CnUSOwhr.mjs";
 import { a as tagUnresolvedTextAsCommentary } from "./assistant-text-phase-C20rxWwP.mjs";
-import { t as createAssistantOutput } from "./assistant-output-iqnlJCV2.mjs";
-import { t as resolveOpencodeSessionHeaders } from "./session-affinity-CCH7eYdB.mjs";
-import { c as flattenCompletionMessagesToStringContent, d as canonicalizeMaxTokensParam, f as resolveMaxTokensParam, l as stripCompletionMessagesToRoleContent, n as shouldEmitOpenAICompletionsReasoning, o as isAzureOpenAICompatibleHost, p as createDeepSeekTextFilter, r as buildOpenAICompletionsParams, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream, u as applyCompletionsAnthropicCacheControl } from "./openai-completions-stream-BQk3SkLD.mjs";
-import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-CVn9eFpF.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
-import { i as normalizeOpenAIReasoningEffort, l as supportsOpenAITemperature, o as resolveOpenAIReasoningEffortForModel } from "./openai-reasoning-effort-BK7FbcLT.mjs";
-import { _ as OpenAIResponsesWebSocketPostDispatchError, a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, d as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, f as OPENAI_RESPONSES_APIS, i as sanitizeResponsesImagePayload, l as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch, v as OpenAIResponsesWebSocketPreDispatchError, x as parseOpenAIResponsesWebSocketServerError, y as OpenAIResponsesWebSocketSafeRetryError } from "./openai-responses-compaction-window-D5jbzCi3.mjs";
-import { $ as resolveReplayableResponsesMessageId, B as resolveAzureOpenAIApiVersion, C as summarizeResponsesFailedNoDetailsObservation, G as recordResponsesInputReplay, H as buildResponsesInputMessage, J as buildOpenAIResponsesReasoningReplayMetadata, K as responsesInputFingerprint, Q as suppressOpenAIResponsesCompaction, R as createResponsesStreamWithEncryptedContentRetry, S as summarizeOpenAITransportError, T as summarizeResponsesTools, U as convertResponsesMessages, V as resolveNextResponsesEncryptedContentAttempt, W as createOpenAIResponsesAssistantOutput, X as isOpenAIResponsesReplayContext, Y as captureOpenAIResponsesCompaction, Z as resolveNewestOpenAIResponsesCompactionReplay, _ as logResponsesFailedNoDetails, b as stringifyRedactedEvent, c as convertProjectedResponsesTools, g as buildResponsesFailedNoDetailsObservation, h as ResponsesStreamFailure, m as observeResponsesStream, n as applyResponsesServiceTierPricing, q as CompactionReplayRefreshRequiredError, u as processResponsesStream, v as normalizeResponsesFailedEvent, w as summarizeResponsesPayload, x as stringifyRedactedPayload, y as safeDebugValue, z as isInvalidEncryptedContentError } from "./openai-responses-shared-ZyQEzS5i.mjs";
+import { t as createAssistantOutput } from "./assistant-output-BsEkB-vU.mjs";
+import { n as resolveOpencodeSessionHeaders } from "./session-affinity-Bcunsn4I.mjs";
+import { c as flattenCompletionMessagesToStringContent, d as canonicalizeMaxTokensParam, f as resolveMaxTokensParam, l as stripCompletionMessagesToRoleContent, n as shouldEmitOpenAICompletionsReasoning, o as isAzureOpenAICompatibleHost, p as createDeepSeekTextFilter, r as buildOpenAICompletionsParams, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream, u as applyCompletionsAnthropicCacheControl } from "./openai-completions-stream-Bu98b0Hv.mjs";
+import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-CyWnYlh0.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C9ZadkJW.mjs";
+import { d as OpenAIResponsesWebSocketSafeRetryError, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-CkGToCD2.mjs";
+import { a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, i as sanitizeResponsesImagePayload, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch } from "./openai-responses-compaction-window-D6P5oZP5.mjs";
+import { A as resolveNextResponsesEncryptedContentAttempt, B as responsesContinuationPrefixFingerprint, D as createResponsesStreamWithEncryptedContentRetry, F as createOpenAIResponsesAssistantOutput, G as CompactionReplayRefreshRequiredError, H as isConfigurationUpdate, I as recordResponsesInputReplay, J as isOpenAIResponsesReplayContext, K as buildOpenAIResponsesReasoningReplayMetadata, L as responsesInputFingerprint, M as resolveResponsesContextUsageBoundary, O as isInvalidEncryptedContentError, R as claimOpenAIResponsesHttpContinuation, U as replayResponsesReasoningUpdates, V as responsesContinuationRequestFingerprint, W as supportsResponsesReasoningUpdate, X as suppressOpenAIResponsesCompaction, Y as resolveNewestOpenAIResponsesCompactionReplay, Z as resolveReplayableResponsesMessageId, c as processResponsesStream, d as logResponsesFailedNoDetails, f as safeDebugValue, j as recordResponsesContextUsage, k as resolveAzureOpenAIApiVersion, l as observeResponsesStream, m as summarizeResponsesPayload, n as applyResponsesServiceTierPricing, p as summarizeOpenAITransportError, q as captureOpenAIResponsesCompaction, u as ResponsesStreamFailure, z as resolveResponsesContinuationRequest } from "./openai-responses-shared-CwsziD_m.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
-import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-tApyTLVu.mjs";
+import { a as sanitizeOpenAICodexResponsesParams, n as buildOpenAIResponsesCompactSystemMessage, r as buildOpenAIResponsesParams, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-C15_-OwV.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
 import { ResponsesWS } from "openai/resources/responses/ws.js";
@@ -117,7 +117,6 @@ function readAnthropicSseChunk(reader, signal) {
 			if (settled) return;
 			settled = true;
 			signal.removeEventListener("abort", onAbort);
-			reader.cancel(signal.reason).catch(() => void 0);
 			reject(createAbortError(signal));
 		};
 		if (signal.aborted) {
@@ -182,7 +181,11 @@ async function* parseAnthropicSseBody(body, signal) {
 			if (data && data !== "[DONE]") yield parseAnthropicSseEventData(data);
 		}
 	} finally {
-		if (!completed) await reader.cancel(signal?.reason).catch(() => void 0);
+		if (!completed) {
+			const cancellation = reader.cancel(signal?.reason).catch(() => void 0);
+			if (signal?.aborted) getAiTransportHost().observePendingProviderWork?.(cancellation);
+			else await cancellation;
+		}
 		reader.releaseLock();
 	}
 }
@@ -208,19 +211,20 @@ function createAnthropicMessagesClient(params) {
 		};
 	} } };
 }
-function formatAnthropicMessagesHttpError(response, detail) {
-	const retryAfterSeconds = parseRetryAfterHeadersSeconds(response.headers);
-	const retryAfterSuffix = Number.isFinite(retryAfterSeconds) ? `; Retry-After: ${Math.ceil(retryAfterSeconds ?? 0)} seconds` : "";
-	return `HTTP ${response.status}: ${detail || "Anthropic Messages request failed"}${retryAfterSuffix}`;
-}
-async function readAnthropicMessagesErrorBodySnippet(response) {
+async function readAnthropicMessagesErrorBody(response) {
 	try {
-		return await readResponseTextSnippet(response, {
+		const text = await readResponseTextSnippet(response, {
 			maxBytes: ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES,
-			maxChars: ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS,
+			maxChars: ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES,
 			chunkTimeoutMs: ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS,
 			onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Anthropic Messages error response stalled: no data received for ${chunkTimeoutMs}ms`)
 		}) ?? "";
+		try {
+			return JSON.parse(text);
+		} catch {
+			const redacted = redactDiagnosticText(text);
+			return redacted.length > ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS ? `${truncateUtf16Safe(redacted, ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS)}…` : redacted;
+		}
 	} catch (error) {
 		if (error instanceof Error && error.message.startsWith("Anthropic Messages error response stalled:")) return error.message;
 		return "";
@@ -248,7 +252,7 @@ function createAnthropicTransportClient(params) {
 			isOAuthToken: false
 		};
 	}
-	if (usesFoundryBearerAuth(resolveModelHeaderSentinels$1(model))) {
+	if (usesFoundryBearerAuth(resolveModelHeaderSentinels(model))) {
 		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
 		return {
 			client: createAnthropicMessagesClient({
@@ -318,11 +322,14 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		authProfileId: options?.authProfileId,
 		sessionId: options?.sessionId
 	});
+	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
 	const messages = await convertAnthropicMessages(transformTransportMessages(replayPlan.messages, model, normalizeAnthropicToolCallId), model, isOAuthToken, {
 		profile: "transport",
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
+		allowEmptySignature: model.compat?.allowEmptySignature,
 		compaction: replayPlan.compaction,
-		replayThinkingEnabled
+		replayThinkingEnabled,
+		cacheBreakpointOptOutMessageIndexes
 	});
 	const params = {
 		model: resolveAnthropicRequestModelId(model),
@@ -342,7 +349,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		toolProjection,
 		profile: "transport"
 	}));
-	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools);
+	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools, cacheBreakpointOptOutMessageIndexes);
 	return {
 		params,
 		toolProjection,
@@ -388,7 +395,7 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 	}
 	if (!reasoning) {
 		resolved.thinkingEnabled = defaultsClaudeAdaptiveThinking(model);
-		if (resolved.thinkingEnabled) resolved.effort = "high";
+		if (resolved.thinkingEnabled) resolved.effort = resolveAnthropicThinkingEffort(model, reasoning);
 		return resolved;
 	}
 	if (supportsClaudeAdaptiveThinking(model)) {
@@ -427,13 +434,12 @@ function createAnthropicMessagesTransportStreamFn() {
 				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions);
 				usedCompactionReplay = builtParams.usedCompactionReplay;
 				let params = builtParams.params;
-				const toolProjection = builtParams.toolProjection;
 				applyAnthropicContextManagementToRequest(params, model, transportOptions, directApiKeyBetaHeader);
 				const nextParams = await transportOptions.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				applyClaudeRequestContract(params, model);
 				const betaHeader = resolveAnthropicContextManagementBetaHeader(params, directApiKeyBetaHeader);
-				const bindingHeaders = applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader !== void 0 ? { "anthropic-beta": betaHeader } : void 0);
+				const bindingHeaders = applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader ? { "anthropic-beta": betaHeader } : void 0);
 				const { response, stream: anthropicStream } = await client.messages.stream({
 					...params,
 					stream: true
@@ -447,8 +453,12 @@ function createAnthropicMessagesTransportStreamFn() {
 					model
 				});
 				if (!response.ok) {
-					const detail = await readAnthropicMessagesErrorBodySnippet(response);
-					throw new Error(formatAnthropicMessagesHttpError(response, detail));
+					const errorBody = await readAnthropicMessagesErrorBody(response);
+					throw Object.assign(/* @__PURE__ */ new Error(`${response.status} status code (no body)`), {
+						status: response.status,
+						headers: response.headers,
+						errorBody
+					});
 				}
 				await consumeAnthropicStream({
 					events: anthropicStream,
@@ -458,7 +468,7 @@ function createAnthropicMessagesTransportStreamFn() {
 					stream,
 					refusalBuffer,
 					isOAuthToken,
-					toolProjection,
+					toolProjection: builtParams.toolProjection,
 					profile: "transport"
 				});
 				finalizeTransportStream({
@@ -476,7 +486,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							refusalBuffer.discard();
 							output.content = [];
 						} else output.content = output.content.filter((block) => block.type !== "toolCall");
-						if (usedCompactionReplay && isAnthropicReplayRejection(error)) suppressAnthropicCompaction(output, model, options);
+						if (usedCompactionReplay && isAnthropicReplayRejection(output)) suppressAnthropicCompaction(output, model, options);
 						for (const block of output.content) delete block.index;
 					}
 				});
@@ -562,8 +572,8 @@ function createSseDoneDetector() {
 		sawDone: () => sawDone
 	};
 }
-function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, opts) {
-	const clientConfig = buildOpenAICompletionsClientConfig(model, context, optionHeaders);
+function createOpenAICompletionsClient(model, apiKey, headers, opts) {
+	const clientConfig = buildOpenAICompletionsClientConfig(model, headers);
 	return new OpenAI({
 		apiKey,
 		baseURL: clientConfig.baseURL,
@@ -574,8 +584,7 @@ function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, op
 		...buildOpenAISdkClientOptions(model)
 	});
 }
-function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
-	const headers = buildOpenAIClientHeaders(model, context, optionHeaders);
+function buildOpenAICompletionsClientConfig(model, headers) {
 	const defaultQuery = {};
 	let baseURL = model.baseUrl;
 	let isAzureHost = false;
@@ -632,6 +641,14 @@ function createOpenAICompletionsTransportStreamFn() {
 			let firstEventAbort;
 			try {
 				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const turnState = resolveProviderTransportTurnState(model, {
+					sessionId: options?.sessionId,
+					turnId: randomUUID(),
+					attempt: 1,
+					transport: "stream"
+				});
+				const optionHeaders = resolveOpencodeSessionHeaders(model, options);
+				const turnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
 				const doneDetector = createSseDoneDetector();
 				const baseFetch = buildGuardedModelFetch(model);
 				const doneDetectingFetch = async (url, init) => {
@@ -653,7 +670,11 @@ function createOpenAICompletionsTransportStreamFn() {
 						statusText: response.statusText
 					});
 				};
-				const client = createOpenAICompletionsClient(model, context, apiKey, resolveOpencodeSessionHeaders(model, options), { fetch: doneDetectingFetch });
+				const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+				const client = createOpenAICompletionsClient(model, apiKey, buildOpenAIClientHeaders(model, context, {
+					...turnHeaders,
+					...optionHeaders
+				}, void 0, resolvePromptCacheKey(options, cacheRetention), cacheRetention), { fetch: doneDetectingFetch });
 				let params = buildOpenAICompletionsParams(model, context, options);
 				const nextParams = await options?.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
@@ -710,374 +731,6 @@ function createOpenAICompletionsTransportStreamFn() {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-responses-params-internal.ts
-const OPENAI_RESPONSES_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
-	"openai",
-	"opencode",
-	"azure-openai-responses",
-	"github-copilot"
-]);
-function resolveOpenAIReasoningEffort(options) {
-	return normalizeOpenAIReasoningEffort(options?.reasoningEffort ?? options?.reasoning ?? "high");
-}
-function hasResponsesWebSearchTool(tools) {
-	if (!Array.isArray(tools)) return false;
-	return tools.some((tool) => {
-		if (!isRecord(tool)) return false;
-		if (tool.type === "web_search") return true;
-		if (tool.type === "function" && tool.name === "web_search") return true;
-		const fn = tool.function;
-		return isRecord(fn) && fn.name === "web_search";
-	});
-}
-function raiseMinimalReasoningForResponsesWebSearch(params) {
-	if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
-	for (const effort of [
-		"low",
-		"medium",
-		"high"
-	]) {
-		const resolved = resolveOpenAIReasoningEffortForModel({
-			model: params.model,
-			effort
-		});
-		if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
-	}
-	return params.effort;
-}
-const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
-	"max_output_tokens",
-	"metadata",
-	"prompt_cache_retention",
-	"prompt_cache_options",
-	"service_tier",
-	"temperature",
-	"top_p"
-];
-function stripOpenAICodexResponsesUnsupportedTextFields(params) {
-	const text = params.text;
-	if (!text || typeof text !== "object" || Array.isArray(text)) return;
-	const sanitizedText = { ...text };
-	delete sanitizedText.format;
-	if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
-	else delete params.text;
-}
-function sanitizeOpenAICodexResponsesParams(model, params) {
-	if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
-	for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
-	Object.assign(params, { store: false });
-	stripOpenAICodexResponsesUnsupportedTextFields(params);
-	return params;
-}
-function buildOpenAIResponsesInstructionsText(context) {
-	if (!context.systemPrompt) return;
-	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
-}
-function resolveOpenAIResponsesInstructions(model, context, usesInstructionsField) {
-	if (!usesInstructionsField) return;
-	const instructions = buildOpenAIResponsesInstructionsText(context);
-	if (instructions && instructions.trim().length > 0) return instructions;
-	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
-}
-function buildOpenAIResponsesCompactSystemMessage(model, instructions) {
-	const compat = getCompat(model);
-	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
-	const role = model.reasoning && supportsDeveloperRole !== false ? "developer" : "system";
-	return buildResponsesInputMessage(role, [{
-		type: "input_text",
-		text: instructions
-	}]);
-}
-function ensureOpenAIResponsesNonEmptyInput(messages, context) {
-	if (messages.length > 0 || !context.systemPrompt) return;
-	if (!buildOpenAIResponsesInstructionsText(context)) throw new Error("OpenAI Responses requires non-empty input when only systemPrompt is provided.");
-	messages.push(buildResponsesInputMessage("user", [{
-		type: "input_text",
-		text: " "
-	}]));
-}
-function resolveOpenAIResponsesTextFormat(responseFormat) {
-	if (responseFormat.type === "json_schema" && responseFormat.json_schema && typeof responseFormat.json_schema === "object" && !Array.isArray(responseFormat.json_schema)) return {
-		...responseFormat.json_schema,
-		type: "json_schema"
-	};
-	return responseFormat;
-}
-function convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode) {
-	const isNativeCodexResponses = usesNativeOpenAICodexResponsesBackend(model);
-	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
-	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
-	const replayResponsesItemIds = !isNativeCodexResponses && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
-	return convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
-		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
-		replayReasoningItems: true,
-		replayResponsesItemIds,
-		authProfileId: options?.authProfileId,
-		sessionId: options?.sessionId,
-		replayMode
-	});
-}
-function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
-	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
-	const messages = convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode);
-	ensureOpenAIResponsesNonEmptyInput(messages, context);
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-	const compat = getCompat(model);
-	const promptCacheKey = compat.supportsPromptCacheKey ? resolvePromptCacheKey(options, cacheRetention) : void 0;
-	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
-	const params = {
-		model: model.id,
-		input: messages,
-		stream: true,
-		prompt_cache_key: promptCacheKey,
-		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
-		...instructions ? { instructions } : {},
-		...metadata ? { metadata } : {}
-	};
-	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
-	if (effectiveMaxTokens) params.max_output_tokens = Math.max(effectiveMaxTokens, 16);
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
-	if (options?.topP !== void 0 && model.id !== "gpt-6-astra") params.top_p = options.topP;
-	if (options?.responseFormat !== void 0) params.text = {
-		...params.text,
-		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
-	};
-	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
-	if (context.tools) {
-		const tools = context.tools;
-		const strict = resolveOpenAIStrictToolSetting(model, { transport: "stream" });
-		const projection = projectOpenAITools(tools);
-		const converted = convertProjectedResponsesTools(projection, strict, model);
-		if (converted.length > 0 || projection.inputToolCount === 0 && projection.diagnostics.length === 0) params.tools = converted;
-		if (options?.toolChoice) {
-			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, projection);
-			if (toolChoice !== void 0) params.tool_choice = toolChoice;
-		}
-	}
-	if (model.reasoning) {
-		if (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) {
-			const requestedReasoningEffort = resolveOpenAIReasoningEffort(options);
-			const resolvedReasoningEffort = resolveOpenAIReasoningEffortForModel({
-				model,
-				effort: requestedReasoningEffort
-			});
-			const reasoningEffort = resolvedReasoningEffort ? raiseMinimalReasoningForResponsesWebSearch({
-				model,
-				effort: resolvedReasoningEffort,
-				tools: params.tools
-			}) : void 0;
-			if (reasoningEffort) {
-				params.reasoning = {
-					effort: reasoningEffort,
-					...reasoningEffort === "none" ? {} : { summary: options?.reasoningSummary || "auto" }
-				};
-				if (reasoningEffort !== "none") params.include = ["reasoning.encrypted_content"];
-			}
-		} else if (model.provider !== "github-copilot") {
-			const reasoningEffort = resolveOpenAIReasoningEffortForModel({
-				model,
-				effort: "none"
-			});
-			if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
-		}
-	}
-	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
-	return sanitizeOpenAICodexResponsesParams(model, params);
-}
-//#endregion
-//#region packages/ai/src/transports/openai-responses-reasoning-update.ts
-function isConfigurationUpdate(value) {
-	return isRecord(value) && value.type === "configuration_update" && isRecord(value.reasoning) && typeof value.reasoning.effort === "string";
-}
-function isResponsesReasoningUpdateCompatible(request) {
-	const mode = isRecord(request.reasoning) ? request.reasoning.mode : void 0;
-	return request.model === "gpt-6-astra" && (mode === void 0 || mode === "standard") && (!isRecord(request.multi_agent) || request.multi_agent.enabled !== true) && request.truncation !== "auto" && (!Array.isArray(request.context_management) || !request.context_management.some((item) => isRecord(item) && item.type === "compaction"));
-}
-function supportsResponsesReasoningUpdate(request) {
-	return isResponsesReasoningUpdateCompatible(request) && isRecord(request.reasoning) && typeof request.reasoning.effort === "string";
-}
-function canReferenceResponsesReasoningHistory(previous, request) {
-	return !previous.input?.some(isConfigurationUpdate) || isResponsesReasoningUpdateCompatible(request);
-}
-/** Rehydrate input controls only provisionally; continuation must validate the full prefix. */
-function replayResponsesReasoningUpdates(previous, request, previousOutputLength, steering) {
-	if (steering !== "required-input" && (!supportsResponsesReasoningUpdate(previous) || !supportsResponsesReasoningUpdate(request)) || !Array.isArray(previous.input) || !Array.isArray(request.input) || request.input.some(isConfigurationUpdate)) return request;
-	const input = [...request.input];
-	let activeEffort = isRecord(previous.reasoning) ? previous.reasoning.effort : void 0;
-	for (const [index, item] of previous.input.entries()) if (isConfigurationUpdate(item)) {
-		input.splice(index, 0, item);
-		activeEffort = item.reasoning.effort;
-	}
-	if (steering === "required-input") return input.length === request.input.length ? request : {
-		...request,
-		input
-	};
-	if (!isRecord(previous.reasoning) || !isRecord(request.reasoning) || typeof request.reasoning.effort !== "string") return request;
-	if (activeEffort !== request.reasoning.effort && steering !== "automatic") {
-		const baselineLength = previous.input.length + previousOutputLength;
-		const nextUser = input.findIndex((item, index) => index >= baselineLength && "role" in item && item.role === "user");
-		if (nextUser === -1) return request;
-		input.splice(nextUser, 0, {
-			type: "configuration_update",
-			reasoning: { effort: request.reasoning.effort }
-		});
-	}
-	if (input.length === request.input.length && activeEffort === request.reasoning.effort) return request;
-	return {
-		...request,
-		reasoning: {
-			...request.reasoning,
-			effort: previous.reasoning.effort
-		},
-		input
-	};
-}
-//#endregion
-//#region packages/ai/src/transports/openai-responses-continuation.ts
-const HTTP_CONTINUATION_IDLE_TTL_MS = 3e5;
-const TURN_HEADERS = /* @__PURE__ */ new Set([
-	"traceparent",
-	"x-openclaw-turn-id",
-	"x-openclaw-turn-attempt"
-]);
-function jsonValuesEqual(left, right) {
-	const leftJson = JSON.stringify(left);
-	const normalizedLeft = stableStringify(JSON.parse(leftJson));
-	const rightJson = JSON.stringify(right);
-	return leftJson === rightJson || normalizedLeft === stableStringify(JSON.parse(rightJson));
-}
-function requestWithoutInput(request) {
-	const { input: _input, previous_response_id: _previousResponseId, instructions: _instructions, tools: _tools, ...rest } = request;
-	if (!isRecord(rest.metadata)) return rest;
-	const metadata = Object.fromEntries(Object.entries(rest.metadata).filter(([key]) => key !== "openclaw_turn_id" && key !== "openclaw_turn_attempt"));
-	return {
-		...rest,
-		metadata
-	};
-}
-function normalizeAssistantReplayInput(input, fromResponse = false) {
-	return input.map((item) => {
-		if (!isRecord(item)) return item;
-		if (item.type === "reasoning") return { type: "reasoning" };
-		if (item.type !== "function_call" && !(item.type === "message" && item.role === "assistant")) return item;
-		const { id: _id, status: _status, ...stableItem } = item;
-		if (fromResponse && item.type === "function_call") {
-			const args = parseJsonObjectPreservingUnsafeIntegers(stableItem.arguments);
-			stableItem.arguments = args ? JSON.stringify(args) : stableItem.arguments;
-		}
-		if (item.type === "message" && Array.isArray(stableItem.content)) stableItem.content = stableItem.content.map((part) => {
-			if (!isRecord(part) || part.type !== "output_text") return part;
-			const { annotations: _annotations, logprobs: _logprobs, ...stablePart } = part;
-			return stablePart;
-		});
-		return stableItem;
-	});
-}
-function responsesContinuationRequestFingerprint(request) {
-	const serialized = JSON.stringify(requestWithoutInput(request));
-	return sha256Hex(stableStringify(JSON.parse(serialized)));
-}
-function responsesContinuationPrefixFingerprint(input, output = []) {
-	const serialized = JSON.stringify([...normalizeAssistantReplayInput(input), ...normalizeAssistantReplayInput(output, true)]);
-	return sha256Hex(stableStringify(JSON.parse(serialized)));
-}
-function resolveResponsesContinuationRequest(continuation, request, steering) {
-	if (!continuation) return {
-		request,
-		continuationStatus: "no_previous_response"
-	};
-	if (request.previous_response_id) return {
-		request,
-		continuationStatus: "explicit_previous_response_id"
-	};
-	if (!canReferenceResponsesReasoningHistory(continuation.lastRequest, request)) return {
-		request,
-		continuationStatus: "request_changed"
-	};
-	const prepared = replayResponsesReasoningUpdates(continuation.lastRequest, request, continuation.lastResponseItems.length, steering);
-	if (steering !== "required-input" && !jsonValuesEqual(requestWithoutInput(prepared), requestWithoutInput(continuation.lastRequest))) return {
-		request,
-		continuationStatus: "request_changed"
-	};
-	const currentInput = prepared.input ?? [];
-	const previousInput = continuation.lastRequest.input ?? [];
-	const baselineLength = previousInput.length + continuation.lastResponseItems.length;
-	if (currentInput.length < baselineLength) return {
-		request,
-		continuationStatus: "history_shorter"
-	};
-	if (!jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(0, previousInput.length)), normalizeAssistantReplayInput(previousInput)) || !jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(previousInput.length, baselineLength)), normalizeAssistantReplayInput(continuation.lastResponseItems, true))) return {
-		request,
-		continuationStatus: "history_changed"
-	};
-	return {
-		request: {
-			...prepared,
-			previous_response_id: continuation.lastResponseId,
-			input: currentInput.slice(baselineLength)
-		},
-		...prepared !== request ? { fullRequest: prepared } : {},
-		continuationStatus: "continued"
-	};
-}
-const httpContinuationEntries = /* @__PURE__ */ new Map();
-function deleteHttpContinuationIfOwned(key, entry) {
-	if (httpContinuationEntries.get(key) === entry) httpContinuationEntries.delete(key);
-}
-function connectionIdentity(params) {
-	const headers = Object.entries(resolveAiTransportHeaderSentinels(params.headers) ?? {}).map(([name, value]) => [name.toLowerCase(), value]).filter(([name]) => !TURN_HEADERS.has(name)).toSorted(([a], [b]) => a.localeCompare(b));
-	return sha256Hex(JSON.stringify([
-		getAiTransportHost().resolveSecretSentinel(params.apiKey),
-		params.baseUrl,
-		headers
-	]));
-}
-function claimOpenAIResponsesHttpContinuation(params) {
-	const key = `${params.sessionId}\0${connectionIdentity(params)}`;
-	const previous = httpContinuationEntries.get(key);
-	if (previous?.kind === "claimed") return;
-	if (previous?.kind === "ready") clearTimeout(previous.idleTimer);
-	const claimed = {
-		kind: "claimed",
-		sessionId: params.sessionId
-	};
-	httpContinuationEntries.set(key, claimed);
-	try {
-		const request = previous?.kind === "ready" ? params.request : params.restoreRequest?.() ?? params.request;
-		const resolved = resolveResponsesContinuationRequest(previous?.kind === "ready" ? previous.state : void 0, request);
-		const fullRequest = resolved.fullRequest ?? request;
-		return {
-			request: params.request.store === false ? fullRequest : resolved.request,
-			fullRequest,
-			commit: (effectiveRequest, response) => {
-				if (httpContinuationEntries.get(key) !== claimed) return;
-				const ready = {
-					...claimed,
-					kind: "ready",
-					state: {
-						lastRequest: effectiveRequest,
-						lastResponseId: response.id,
-						lastResponseItems: response.output
-					},
-					idleTimer: setTimeout(() => deleteHttpContinuationIfOwned(key, ready), HTTP_CONTINUATION_IDLE_TTL_MS)
-				};
-				ready.idleTimer.unref?.();
-				httpContinuationEntries.set(key, ready);
-			},
-			release: () => deleteHttpContinuationIfOwned(key, claimed)
-		};
-	} catch (error) {
-		deleteHttpContinuationIfOwned(key, claimed);
-		throw error;
-	}
-}
-registerSessionResourceCleanup((sessionId) => {
-	for (const [key, entry] of httpContinuationEntries) if (!sessionId || entry.sessionId === sessionId) {
-		if (entry.kind === "ready") clearTimeout(entry.idleTimer);
-		httpContinuationEntries.delete(key);
-	}
-});
-//#endregion
 //#region packages/ai/src/transports/openai-responses-steering.ts
 function cloneWireRequest(request) {
 	const serialized = JSON.stringify(request);
@@ -1699,34 +1352,27 @@ function combineWebSocketTimeoutSignal(signal, model, timeoutMs) {
 	if (resolvedTimeoutMs === void 0 || !Number.isFinite(resolvedTimeoutMs)) return signal;
 	return AbortSignal.any([signal, AbortSignal.timeout(Math.max(1, resolvedTimeoutMs))]);
 }
-function resolveProviderTransportTurnState(model, params) {
-	const normalizedProvider = model.provider.trim().toLowerCase();
-	const allowRuntimePluginLoad = normalizedProvider === "openai" || normalizedProvider === "azure-openai" || normalizedProvider === "azure-openai-responses";
-	return getAiTransportHost().plugin.resolveTransportTurnState({
-		provider: model.provider,
-		modelId: model.id,
-		allowRuntimePluginLoad,
-		context: {
-			provider: model.provider,
-			modelId: model.id,
-			model,
-			sessionId: params.sessionId,
-			turnId: params.turnId,
-			attempt: params.attempt,
-			transport: params.transport
-		}
-	});
-}
-function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId, fetchOverride) {
+function createOpenAIResponsesClient(model, apiKey, defaultHeaders, fetchOverride) {
 	return new OpenAI({
 		apiKey,
 		baseURL: resolveOpenAIClientBaseUrl(model),
 		dangerouslyAllowBrowser: true,
-		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId),
+		defaultHeaders,
 		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
 	});
 }
+function withDefaultResponsesStreamEncoding(fetch) {
+	return (input, init) => {
+		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		if (headers.has("accept-encoding")) return fetch(input, init);
+		headers.set("accept-encoding", "identity");
+		return fetch(input, {
+			...init,
+			headers
+		});
+	};
+}
 function createResponsesTransportExecutor(config) {
 	return (model, context, options) => {
 		const responsesOptions = options;
@@ -1746,8 +1392,11 @@ function createResponsesTransportExecutor(config) {
 					transport: websocketMode ? "websocket" : "stream"
 				});
 				const websocketSessionPolicy = websocketMode ? turnState?.websocket : void 0;
-				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketSessionPolicy?.headers, options?.sessionId) : void 0;
-				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId, compactRequest ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : void 0);
+				const httpTurnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
+				const websocketTurnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, websocketSessionPolicy?.headers);
+				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketTurnHeaders, options?.sessionId, options?.cacheRetention) : void 0;
+				const httpHeaders = buildOpenAIClientHeaders(model, context, options?.headers, httpTurnHeaders, options?.sessionId, options?.cacheRetention);
+				const client = config.createClient(model, apiKey, httpHeaders, compactRequest ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : config.streamRequest ? withDefaultResponsesStreamEncoding(buildGuardedModelFetch(model)) : void 0);
 				const nativeAstra = model.id === "gpt-6-astra" && supportsNativeOpenAIResponsesEndpoint(model);
 				const asyncToolExecutionEligible = nativeAstra && options?.asyncToolExecution === true && !responsesOptions?.openclawCodeModeToolSurface;
 				const prepareRequest = async (request) => {
@@ -1791,16 +1440,16 @@ function createResponsesTransportExecutor(config) {
 					return;
 				}
 				const sessionId = options?.sessionId;
-				if (config.httpContinuation && !websocketMode && !getAiTransportHost().requiresManagedTransport(model) && supportsNativeOpenAIResponsesEndpoint({
+				if (config.httpContinuation && !websocketMode && !getAiTransportHost().requiresManagedTransport(model) && (supportsNativeOpenAIResponsesEndpoint({
 					provider: model.provider,
 					api: model.api,
 					baseUrl: model.baseUrl
-				}) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
+				}) || resolveOpenAIResponsesPayloadPolicy(model).explicitContinuationOptIn) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
 					continuationClaim = claimOpenAIResponsesHttpContinuation({
 						sessionId,
 						apiKey,
 						baseUrl: model.baseUrl,
-						headers: buildOpenAIClientHeaders(model, context, options?.headers, turnState?.headers, sessionId),
+						headers: httpHeaders,
 						request: params,
 						restoreRequest: () => restoreResponsesReasoningState(context, model, responsesOptions, params)
 					});
@@ -1826,7 +1475,9 @@ function createResponsesTransportExecutor(config) {
 				});
 				const websocketSignal = combineWebSocketTimeoutSignal(firstEvent.signal, model, requestOptions?.timeout);
 				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} requestIdHash=${redactIdentifier(options?.requestId, { len: 64 })} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
+				const responseModelTracker = createResponseModelTracker(isOpenAICodexResponsesModel(model));
 				let continuationBaseline;
+				let contextUsageEligible = true;
 				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
 					const { stream: responseStream } = await createResponsesStreamWithEncryptedContentRetry({
 						client,
@@ -1840,9 +1491,11 @@ function createResponsesTransportExecutor(config) {
 						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint),
 						canRetryStream: () => output.content.length === 0,
 						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
+							contextUsageEligible &&= attempt.kind === "initial";
 							continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
+							const trackedResponseStream = responseModelTracker.track(response, rawResponseStream);
 							return withProviderResponseHook({
-								stream: observeResponsesStream(rawResponseStream, model, requestStartedAt),
+								stream: observeResponsesStream(trackedResponseStream, model, requestStartedAt),
 								signal: firstEvent.signal,
 								abort: firstEvent.abort,
 								hook: createOpenAIProviderAcceptanceHook(options, response, model),
@@ -1878,24 +1531,29 @@ function createResponsesTransportExecutor(config) {
 						callerSignal: options?.signal,
 						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs,
 						onActiveResponse: nativeAstra && params.model === "gpt-6-astra" ? options?.onActiveResponse : void 0,
-						steeringInput: (messages) => projectResponsesSteeringInput(params, () => buildRequest("checkpoint", {
-							...context,
-							messages: [...context.messages, ...messages]
-						}))
+						steeringInput: (messages) => {
+							contextUsageEligible = false;
+							return projectResponsesSteeringInput(params, () => buildRequest("checkpoint", {
+								...context,
+								messages: [...context.messages, ...messages]
+							}));
+						}
 					});
 					finishWebSocket = websocket.finish;
 					websocketBaseline = websocket.fullRequest;
 					recordResponsesInputReplay(output, websocket.inputReplay);
+					contextUsageEligible &&= websocket.inputReplay === void 0;
 					observePrompt?.(websocket.request, {
 						egress: "responses-websocket",
 						payloadVariant: "initial"
 					});
 					transport = "websocket";
 					emitModelTransportDebug(log, `[responses] websocket_selected provider=${model.provider} api=${model.api} model=${model.id} mode=${websocketMode} reused=${websocket.reusedConnection} continuation=${websocket.continuationStatus === "continued"} continuationStatus=${websocket.continuationStatus} sessionIdHash=${redactIdentifier(options?.sessionId)} headersHash=${redactIdentifier(JSON.stringify(Object.entries(websocketHeaders ?? {}).toSorted(([a], [b]) => a.localeCompare(b))))}`);
+					const trackedWebSocketStream = responseModelTracker.track(void 0, websocket.stream);
 					responseStream = { async *[Symbol.asyncIterator]() {
 						let providerAccepted = false;
 						try {
-							for await (const event of websocket.stream) {
+							for await (const event of trackedWebSocketStream) {
 								if (!providerAccepted) {
 									providerAccepted = true;
 									await notifyProviderStreamOpened({
@@ -1944,7 +1602,8 @@ function createResponsesTransportExecutor(config) {
 							authProfileId: responsesOptions?.authProfileId,
 							sessionId: options?.sessionId
 						}),
-						asyncToolExecution: asyncTools
+						asyncToolExecution: asyncTools,
+						...responseModelTracker.terminalOptions
 					});
 					finishWebSocket?.();
 					if (options?.signal?.aborted) throw transportAbortError(options.signal);
@@ -1952,6 +1611,7 @@ function createResponsesTransportExecutor(config) {
 					const admitted = transport === "websocket" ? websocketBaseline : continuationBaseline;
 					if (terminal && admitted && supportsNativeOpenAIResponsesEndpoint(model)) recordResponsesReasoningState(output, model, responsesOptions, admitted, terminal.output);
 					if (continuationClaim && continuationBaseline && terminal) continuationClaim.commit(continuationBaseline, terminal);
+					if (terminal && admitted && contextUsageEligible) recordResponsesContextUsage(output, model, responsesOptions, admitted, terminal.output, "transport");
 				} catch (error) {
 					finishWebSocket?.({ keep: false });
 					throw error;
@@ -2006,7 +1666,13 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		outputApi: "azure-openai-responses",
 		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
 		createClient: createAzureOpenAIClient,
-		buildRequest: (model, context, options, metadata, replayMode) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata, replayMode)
+		buildRequest: (model, context, options, metadata, replayMode) => {
+			const deploymentName = resolveAzureDeploymentName(model);
+			const params = buildOpenAIResponsesParams(model, context, options, metadata, replayMode);
+			params.model = deploymentName;
+			delete params.store;
+			return params;
+		}
 	});
 }
 function resolveAzureDeploymentName(model) {
@@ -2015,12 +1681,12 @@ function resolveAzureDeploymentName(model) {
 		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
 	});
 }
-function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders, _sessionId, fetchOverride) {
+function createAzureOpenAIClient(model, apiKey, defaultHeaders, fetchOverride) {
 	const baseURL = model.baseUrl.replace(/\/+$/, "");
 	const clientOptions = {
 		apiKey,
 		dangerouslyAllowBrowser: true,
-		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
+		defaultHeaders,
 		baseURL,
 		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
@@ -2031,41 +1697,6 @@ function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHead
 		apiVersion: resolveAzureOpenAIApiVersion()
 	});
 }
-function buildAzureOpenAIResponsesParams(model, context, options, deploymentName, metadata, replayMode = "checkpoint") {
-	const params = buildOpenAIResponsesParams(model, context, options, metadata, replayMode);
-	params.model = deploymentName;
-	delete params.store;
-	return params;
-}
-//#endregion
-//#region packages/ai/src/transports/openai-responses-transport.ts
-/** OpenAI Responses transport facade. */
-const responsesTesting = {
-	getCompat,
-	assertCodeModeResponsesToolSurface,
-	buildOpenAIResponsesParams,
-	buildOpenAIClientHeaders,
-	buildOpenAISdkClientOptions,
-	buildOpenAISdkRequestOptions,
-	createAzureOpenAIClient,
-	createOpenAIResponsesClient,
-	enforceCodeModeResponsesToolSurface,
-	sanitizeOpenAICodexResponsesParams,
-	processResponsesStream,
-	formatModelTransportDebugBaseUrl,
-	buildResponsesFailedNoDetailsObservation,
-	buildOpenAIResponsesReasoningReplayMetadata,
-	isInvalidEncryptedContentError,
-	normalizeResponsesFailedEvent,
-	createResponsesStreamWithEncryptedContentRetry,
-	resolveAzureOpenAIApiVersion,
-	summarizeResponsesFailedNoDetailsObservation,
-	summarizeResponsesPayload,
-	summarizeResponsesTools,
-	stringifyRedactedEvent,
-	stringifyRedactedPayload
-};
-if (process.env.VITEST || false) globalThis.openclawOpenAIResponsesTransportTestApi = responsesTesting;
 //#endregion
 //#region packages/ai/src/transports/provider-compaction-replay.ts
 function isAssistantReplayMessage(message) {
@@ -2123,35 +1754,55 @@ function preserveCompactionReplayWindow(source, windowed, model, identity) {
 		providerReplay
 	}, ...windowed.filter((message) => suffix.has(message))];
 }
-function estimateResponsesWindow(checkpoint, estimate) {
-	return checkpoint.output.reduce((tokens, entry) => {
-		if (entry.type === "compaction") {
+function estimateResponsesContent(content, estimate, text) {
+	if (typeof content === "string") return text(content);
+	if (!Array.isArray(content)) return estimate.json(content);
+	return content.reduce((tokens, block) => {
+		if (!isRecord(block)) return tokens + estimate.json(block);
+		if ((block.type === "input_text" || block.type === "output_text") && typeof block.text === "string") {
+			const { text: value, ...metadata } = block;
+			return tokens + text(value) + estimate.json(metadata);
+		}
+		if (block.type === "input_image") {
+			const { image_url: url, ...metadata } = block;
+			return tokens + estimate.image() + estimate.json(typeof url === "string" && url.startsWith("data:") ? metadata : block);
+		}
+		return tokens + estimate.json(block);
+	}, 0);
+}
+function estimateResponsesInput(input, estimate) {
+	return input.reduce((tokens, entry) => {
+		if (!isRecord(entry)) return tokens + estimate.json(entry);
+		if (entry.type === "compaction" && typeof entry.encrypted_content === "string") {
 			const { encrypted_content, ...metadata } = entry;
 			return tokens + estimate.text(encrypted_content) + estimate.json(metadata);
 		}
-		const { content, ...metadata } = entry;
-		return tokens + estimate.json(metadata) + content.reduce((sum, block) => {
-			if (block.type === "input_text") {
-				const { text, ...fields } = block;
-				return sum + estimate.text(text) + estimate.json(fields);
-			}
-			if (block.type === "input_image") {
-				const { image_url: _imageUrl, ...fields } = block;
-				return sum + estimate.image() + estimate.json(block.image_url?.startsWith("data:") ? fields : block);
-			}
-			return sum + estimate.json(block);
-		}, 0);
+		if (entry.type === "message") {
+			const { content, ...metadata } = entry;
+			return tokens + estimate.json(metadata) + estimateResponsesContent(content, estimate, (value) => estimate.text(value));
+		}
+		if (entry.type === "function_call_output" || entry.type === "custom_tool_call_output") {
+			const { output, ...metadata } = entry;
+			return tokens + estimate.json(metadata) + estimateResponsesContent(output, estimate, (value) => estimate.toolResult ? estimate.toolResult(value) : estimate.text(value));
+		}
+		return tokens + estimate.json(entry);
 	}, 0);
 }
 /** Estimate the canonical prefix and its tail once, independent of unbound usage snapshots. */
-function resolveCompactionReplayPressure(messages, model, identity, estimate) {
+function resolveCompactionReplayPressure(messages, model, identity, estimate, systemPrompt) {
 	const checkpoint = resolveCompactionSource(messages, model, identity);
 	if (!checkpoint) return;
 	if (checkpoint.family === "responses" && checkpoint.mode === "refresh-required") throw new CompactionReplayRefreshRequiredError();
 	const ownerIndex = messages.findIndex((message) => message === checkpoint.owner);
 	const owner = messages[ownerIndex];
 	if (!owner) return;
-	const prefixTokens = checkpoint.family === "anthropic" ? estimate.text(checkpoint.summary) : checkpoint.mode === "complete-window" ? estimateResponsesWindow(checkpoint, estimate) : estimate.text(checkpoint.item.encrypted_content);
+	const prefixTokens = checkpoint.family === "anthropic" ? estimate.text(checkpoint.summary) : checkpoint.mode === "complete-window" ? estimateResponsesInput(checkpoint.output, estimate) : estimate.text(checkpoint.item.encrypted_content);
+	const measuredBoundary = checkpoint.family === "responses" ? resolveResponsesContextUsageBoundary(messages, model, identity, systemPrompt) : void 0;
+	if (measuredBoundary) return {
+		messages: [],
+		prefixTokens: measuredBoundary.totalTokens + estimateResponsesInput(measuredBoundary.suffix, estimate),
+		measuredTokens: measuredBoundary.totalTokens
+	};
 	const { contextUsage: _staleContextUsage, ...usage } = checkpoint.owner.usage;
 	const tail = [];
 	for (const message of messages.slice(ownerIndex + 1)) {
@@ -2322,6 +1973,18 @@ function buildTransportAwareSimpleStreamFn(model, ctx) {
 }
 //#endregion
 //#region packages/ai/src/transports/simple-completion-transport.ts
+/**
+* Simple completion transport preparation.
+*
+* Registers provider-specific stream functions and rewrites models that need OpenClaw-managed transport semantics.
+*/
+/** Standalone completions have no durable session, but may require routing identity. */
+function prepareHeadersForSimpleCompletion(model, options) {
+	return resolveOpencodeSessionHeaders(model, {
+		...options,
+		sessionId: options?.sessionId || randomUUID()
+	});
+}
 const PROVIDER_SIMPLE_COMPLETION_API_PREFIX = "openclaw-provider-simple:";
 const PROVIDER_STREAM_API_PREFIX = "openclaw-provider-stream:";
 const INVALID_CODEX_BASE_URL_MESSAGE = "OpenAI Codex Responses baseUrl must not include query parameters or fragments";
@@ -2416,7 +2079,9 @@ function prepareCodexSimpleTransportModel(registry, model, cfg) {
 	if (!registerCustomApi(registry, api, streamFn)) return;
 	return projectModel(transportModel, { api });
 }
-function resolveModelHeaderSentinels(model) {
+function resolveModelTransportSentinels(model, boundary) {
+	const host = getAiTransportHost();
+	if (host.unwrapModelTransportSentinels) return host.unwrapModelTransportSentinels(model, boundary);
 	const headers = resolveAiTransportHeaderSentinels(model.headers);
 	return headers === model.headers ? model : projectModel(model, { headers });
 }
@@ -2425,7 +2090,7 @@ function wrapPluginProviderStream(streamFn) {
 		const host = getAiTransportHost();
 		const apiKey = options?.apiKey ? host.resolveSecretSentinel(options.apiKey) : options?.apiKey;
 		const headers = resolveAiTransportHeaderSentinels(options?.headers);
-		return streamFn(resolveModelHeaderSentinels(model), context, apiKey === options?.apiKey && headers === options?.headers ? options : {
+		return streamFn(resolveModelTransportSentinels(model, "plugin simple-completion stream egress"), context, apiKey === options?.apiKey && headers === options?.headers ? options : {
 			...options,
 			apiKey,
 			headers
@@ -2433,7 +2098,7 @@ function wrapPluginProviderStream(streamFn) {
 	};
 }
 function prepareProviderStreamModel(params) {
-	const pluginModel = resolveModelHeaderSentinels(params.model);
+	const pluginModel = resolveModelTransportSentinels(params.model, "plugin simple-completion stream construction");
 	const providerStreamFn = getAiTransportHost().plugin.resolveProviderStream({
 		provider: params.model.provider,
 		config: params.cfg,
@@ -2475,4 +2140,4 @@ function prepareModelForSimpleCompletion(params) {
 	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
 }
 //#endregion
-export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyCompletionsAnthropicCacheControl, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildAnthropicSystemBlocks, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, consumeGoogleGenerateContentStream, convertGoogleTools, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isAnthropicServerToolClearingEnabled, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, projectGoogleMessages, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, requiresGoogleToolCallId, resolveAnthropicCacheOptions, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };
+export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, IncompleteToolCallError, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyCompletionsAnthropicCacheControl, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildAnthropicSystemBlocks, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, consumeGoogleGenerateContentStream, convertGoogleTools, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createResponseModelTracker, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isAnthropicServerToolClearingEnabled, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareHeadersForSimpleCompletion, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, projectGoogleMessages, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, requiresGoogleToolCallId, resolveAnthropicCacheOptions, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };