@openclaw/ai 2026.9.1 → 2026.9.2

package/dist/transports.mjs

@@ -1,30 +1,31 @@
-import { g as supportsClaudeAdaptiveThinking, m as resolveClaudeSonnet5ModelIdentity, p as resolveClaudeOpus5ModelIdentity, y as supportsClaudeNativeXhighEffort } from "./src-C8U7lkoa.mjs";
+import { _ as supportsClaudeAdaptiveThinking, b as supportsClaudeNativeXhighEffort, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-2qBGKg8O.mjs";
 import { c as normalizeLowercaseStringOrEmpty, o as isRecord, s as hasNonEmptyString } from "./utf16-slice-qz3nsy87.mjs";
-import { r as calculateCost } from "./sanitize-unicode-S6binQG-.mjs";
-import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, h as defaultsClaudeAdaptiveThinking, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-BIaiBURL.mjs";
-import { i as stableStringify } from "./provider-error-B6EGq6gg.mjs";
-import { r as toErrorObject } from "./diagnostics-KhXK-QJI.mjs";
+import { r as calculateCost } from "./sanitize-unicode-D6xUvZaS.mjs";
+import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, h as defaultsClaudeAdaptiveThinking, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-CEvLw30U.mjs";
+import { i as stableStringify } from "./provider-error-9TraxGvt.mjs";
+import { r as toErrorObject } from "./diagnostics-DfFyKeX_.mjs";
 import { a as asNonNegativeFiniteNumber } from "./base64-CEFBpSkN.mjs";
 import { n as uniqueStrings } from "./string-normalization--fwJ4S2q.mjs";
-import { A as applyAnthropicCacheControlToMessages, C as applyAnthropicFallbackBoundary, D as createAnthropicInlineImageBudget, E as applyAnthropicRefusal, F as resolveAnthropicServerCompactionPlan, I as isAnthropicOAuthApiKey, L as omitFoundryBearerCredentialHeaders, M as applyAnthropicPayloadPolicyToParams, N as resolveAnthropicEphemeralCacheControl, O as normalizeAnthropicInlineContent, P as resolveAnthropicPayloadPolicy, R as usesFoundryBearerAuth, T as resolveAnthropicFallbackServingModelCost, _ as toClaudeCodeToolName, a as suppressAnthropicCompaction, b as ANTHROPIC_SERVER_SIDE_FALLBACKS, f as normalizeAnthropicToolCallId, g as resolveOriginalAnthropicToolName, h as reconcileAnthropicToolChoice, i as resolveNewestAnthropicCompaction, j as applyAnthropicEphemeralCacheControlMarkers, k as resolveAnthropicImageMediaType, m as projectAnthropicTools, n as createCompactionCapture, o as applyAnthropicMessageDeltaUsage, p as normalizeAnthropicToolChoice, r as isAnthropicReplayRejection, s as applyAnthropicMessageStartUsage, t as buildAnthropicReplayPlan, v as ANTHROPIC_OMITTED_REASONING_TEXT, w as readAnthropicFallbackBoundary, x as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, y as findActiveAnthropicToolTurnAssistantIndex } from "./anthropic-compaction-replay-OMJZ0uyo.mjs";
+import { r as resolveOpenAIResponsesCacheParams } from "./openai-prompt-cache-CGnVB74a.mjs";
+import { A as createAnthropicInlineImageBudget, B as resolveAnthropicContextManagementBetaHeader, C as ANTHROPIC_SERVER_SIDE_FALLBACKS, D as readAnthropicFallbackBoundary, E as applyAnthropicFallbackBoundary, F as applyAnthropicEphemeralCacheControlMarkers, G as omitFoundryBearerCredentialHeaders, H as resolveAnthropicPayloadPolicy, I as applyAnthropicPayloadPolicyToParams, K as usesFoundryBearerAuth, L as isAnthropicServerToolClearingEnabled, M as resolveAnthropicImageMediaType, N as applyAnthropicCacheControlToMessages, O as resolveAnthropicFallbackServingModelCost, P as applyAnthropicContextManagementToRequest, R as isDirectAnthropicModel, S as readAnthropicInputTransformations, U as resolveAnthropicServerCompactionPlan, V as resolveAnthropicEphemeralCacheControl, W as isAnthropicOAuthApiKey, _ as toClaudeCodeToolName, a as suppressAnthropicCompaction, b as findActiveAnthropicToolTurnAssistantIndex, f as normalizeAnthropicToolCallId, g as resolveOriginalAnthropicToolName, h as reconcileAnthropicToolChoice, i as resolveNewestAnthropicCompaction, j as normalizeAnthropicInlineContent, k as applyAnthropicRefusal, m as projectAnthropicTools, n as createCompactionCapture, o as applyAnthropicMessageDeltaUsage, p as normalizeAnthropicToolChoice, r as isAnthropicReplayRejection, s as applyAnthropicMessageStartUsage, t as buildAnthropicReplayPlan, v as ANTHROPIC_OMITTED_REASONING_TEXT, w as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, x as logAnthropicThinkingDrops, y as applyAnthropicThinkingBindingControls, z as logAnthropicContextEdits } from "./anthropic-compaction-replay-DB2FGLQc.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-0PLDyJ-d.mjs";
-import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch } from "./tool-schema-json-projection-BtZiml7r.mjs";
-import { a as isGoogleGemini3FlashModel, c as parseRetryAfterSeconds, f as resolveModelHeaderSentinels$1, i as isCodeModeModelVisibleToolName, l as readResponseTextSnippet, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as redactIdentifier } from "./transport-utils-CtuS1Upe.mjs";
+import { a as codeModeToolSurfaceObserver, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking } from "./simple-options-BjHCCh4v.mjs";
+import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch } from "./tool-schema-json-projection-mJhXDcyz.mjs";
+import { a as isGoogleGemini3FlashModel, c as parseRetryAfterSeconds, f as resolveModelHeaderSentinels$1, i as isCodeModeModelVisibleToolName, l as readResponseTextSnippet, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as redactIdentifier } from "./transport-utils-7il795_9.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-CytPVLIg.mjs";
-import { C as createDeepSeekTextFilter, E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, T as tagPendingCommentaryText, _ as hasToolCallHistory, a as buildOpenAISdkClientOptions, b as resolveOpenAICompletionsCompat, c as filterCodeModePayloadTools, d as readCodeModePayloadToolName, f as resolveCodeModeResponsesVisibleToolNames, g as convertMessages, h as resolveOpenAIReasoningEffortMap, i as buildOpenAIClientHeaders, l as getCompat, m as usesNativeOpenAICodexResponsesBackend, n as shouldEmitOpenAICompletionsReasoning, o as buildOpenAISdkRequestOptions, p as resolveOpenAIStrictToolFlagWithDiagnostics, r as assertCodeModeResponsesToolSurface, s as enforceCodeModeResponsesToolSurface, t as processCompletionsStream, u as isOpenAICodexResponsesModel, v as finalizeOpenAICompletionsToolCalls, x as resolveOpenAICompletionsResponseFormat, y as detectOpenAICompletionsCompat } from "./openai-completions-stream-DZjwK8vp.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-CZqMhfIw.mjs";
+import { C as createDeepSeekTextFilter, E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, T as tagPendingCommentaryText, _ as hasToolCallHistory, a as buildOpenAISdkClientOptions, b as resolveOpenAICompletionsCompat, c as filterCodeModePayloadTools, d as readCodeModePayloadToolName, f as resolveCodeModeResponsesVisibleToolNames, g as convertMessages, h as resolveOpenAIReasoningEffortMap, i as buildOpenAIClientHeaders, l as getCompat, m as usesNativeOpenAICodexResponsesBackend, n as shouldEmitOpenAICompletionsReasoning, o as buildOpenAISdkRequestOptions, p as resolveOpenAIStrictToolFlagWithDiagnostics, r as assertCodeModeResponsesToolSurface, s as enforceCodeModeResponsesToolSurface, t as processCompletionsStream, u as isOpenAICodexResponsesModel, v as finalizeOpenAICompletionsToolCalls, x as resolveOpenAICompletionsResponseFormat, y as detectOpenAICompletionsCompat } from "./openai-completions-stream-BsrBe3Gg.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
 import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as googleFlashSupportsMinimalThinking } from "./google-thinking-level-C-V3tecN.mjs";
-import { B as buildResponsesInputMessage, C as summarizeResponsesTools, G as captureOpenAIResponsesCompaction, H as createOpenAIResponsesAssistantOutput, I as createResponsesStreamWithEncryptedContentRetry, J as resolveReplayableResponsesMessageId, K as resolveNewestOpenAIResponsesCompactionReplay, L as isInvalidEncryptedContentError, R as resolveAzureOpenAIApiVersion, S as summarizeResponsesPayload, U as CompactionReplayRefreshRequiredError, V as convertResponsesMessages, W as buildOpenAIResponsesReasoningReplayMetadata, X as resolveModelPayloadDebugMode, Y as emitModelTransportDebug, Z as resolveModelSseDebugMode, _ as safeDebugValue, b as summarizeOpenAITransportError, c as processResponsesStream, f as observeResponsesStream, g as normalizeResponsesFailedEvent, h as logResponsesFailedNoDetails, m as buildResponsesFailedNoDetailsObservation, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, q as suppressOpenAIResponsesCompaction, v as stringifyRedactedEvent, x as summarizeResponsesFailedNoDetailsObservation, y as stringifyRedactedPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DiAdpNAM.mjs";
-import { A as readOpenAICompletionsReasoningBatch, C as createOpenAIProviderAcceptanceHook, D as measureUtf8AppendBytes, E as log, M as resolvePromptCacheKey, N as throwIfModelStreamAborted, O as parseOpenAICompletionsUsage, S as createModelStreamCooperativeScheduler, T as isOpenAICompletionsThinkingEnabled, b as reconcileOpenAIResponsesToolChoice, j as resolveOpenAIClientBaseUrl, k as readOpenAICompletionsContentDeltas, r as normalizeOpenAIStrictToolParameters, v as projectOpenAITools, w as createOpenAIResponseHook, x as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-BMiHFH36.mjs";
+import { $ as resolveModelPayloadDebugMode, B as resolveNextResponsesEncryptedContentAttempt, C as summarizeResponsesPayload, G as responsesInputFingerprint, H as convertResponsesMessages, J as captureOpenAIResponsesCompaction, K as CompactionReplayRefreshRequiredError, L as createResponsesStreamWithEncryptedContentRetry, Q as emitModelTransportDebug, R as isInvalidEncryptedContentError, S as summarizeResponsesFailedNoDetailsObservation, U as createOpenAIResponsesAssistantOutput, V as buildResponsesInputMessage, W as recordResponsesInputReplay, X as suppressOpenAIResponsesCompaction, Y as resolveNewestOpenAIResponsesCompactionReplay, Z as resolveReplayableResponsesMessageId, _ as normalizeResponsesFailedEvent, b as stringifyRedactedPayload, et as resolveModelSseDebugMode, g as logResponsesFailedNoDetails, h as buildResponsesFailedNoDetailsObservation, l as processResponsesStream, m as ResponsesStreamFailure, n as applyResponsesServiceTierPricing, p as observeResponsesStream, q as buildOpenAIResponsesReasoningReplayMetadata, v as safeDebugValue, w as summarizeResponsesTools, x as summarizeOpenAITransportError, y as stringifyRedactedEvent, z as resolveAzureOpenAIApiVersion } from "./openai-responses-shared-Bmma_3Qc.mjs";
+import { A as readOpenAICompletionsReasoningBatch, C as createOpenAIProviderAcceptanceHook, D as measureUtf8AppendBytes, E as log, M as resolvePromptCacheKey, N as throwIfModelStreamAborted, O as parseOpenAICompletionsUsage, S as createModelStreamCooperativeScheduler, T as isOpenAICompletionsThinkingEnabled, b as reconcileOpenAIResponsesToolChoice, j as resolveOpenAIClientBaseUrl, k as readOpenAICompletionsContentDeltas, r as normalizeOpenAIStrictToolParameters, v as projectOpenAITools, w as createOpenAIResponseHook, x as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-_pTAJqKF.mjs";
 import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
-import { C as isOpenAIGpt54MiniModel, D as resolveOpenAIReasoningEffortForModel, E as normalizeOpenAIReasoningEffort, T as isOpenAIGpt56Model, _ 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, w as isOpenAIGpt55Model, x as parseOpenAIResponsesWebSocketServerError, y as OpenAIResponsesWebSocketSafeRetryError } from "./openai-responses-compaction-window-DO7yV7az.mjs";
+import { C as isOpenAIGpt54MiniModel, E as normalizeOpenAIReasoningEffort, O as resolveOpenAIReasoningEffortForModel, T as isOpenAIGpt56Model, _ as OpenAIResponsesWebSocketPostDispatchError, a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, d as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, f as OPENAI_RESPONSES_APIS, i as sanitizeResponsesImagePayload, j as supportsOpenAITemperature, l as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch, v as OpenAIResponsesWebSocketPreDispatchError, w as isOpenAIGpt55Model, x as parseOpenAIResponsesWebSocketServerError, y as OpenAIResponsesWebSocketSafeRetryError } from "./openai-responses-compaction-window-BMVHFOtq.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-C7x4IK7r.mjs";
+import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-D0bhBfgL.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
 import { ResponsesWS } from "openai/resources/responses/ws.js";
@@ -59,11 +60,6 @@ function resolveAnthropicMessagesMaxTokens(params) {
 	const contextWindow = resolvePositiveAnthropicTokenLimit(params.modelContextWindow);
 	return contextWindow === void 0 ? ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS : Math.max(1, Math.min(ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS, Math.floor(contextWindow / ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR)));
 }
-function isDirectAnthropicModel(model) {
-	if (normalizeLowercaseStringOrEmpty(model.provider) !== "anthropic") return false;
-	const endpointClass = resolveProviderEndpoint(model).endpointClass;
-	return endpointClass === "default" || endpointClass === "anthropic-public";
-}
 function isKimiAnthropicProvider(provider) {
 	return /^kimi(?:-|$)/.test(normalizeLowercaseStringOrEmpty(provider ?? ""));
 }
@@ -133,14 +129,12 @@ async function convertAnthropicMessages(messages, model, isOAuthToken, options)
 		const msg = transformedMessages[i];
 		if (!msg) continue;
 		if (msg.role === "user") {
-			const isRuntimeContextCarrier = msg.runtimeContextCarrier === true;
 			if (typeof msg.content === "string") {
 				if (msg.content.trim().length > 0) {
 					const userParam = {
 						role: "user",
 						content: sanitizeTransportPayloadText(msg.content)
 					};
-					if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
 					params.push(userParam);
 				}
 				continue;
@@ -166,7 +160,6 @@ async function convertAnthropicMessages(messages, model, isOAuthToken, options)
 				role: "user",
 				content: filteredBlocks
 			};
-			if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
 			params.push(userParam);
 			continue;
 		}
@@ -402,12 +395,13 @@ async function* parseAnthropicSseBody(body, signal) {
 function createAnthropicMessagesClient(params) {
 	const url = resolveAnthropicMessagesUrl(params.baseURL);
 	return { messages: { async stream(body, options) {
-		const headers = mergeTransportHeaders({
+		const headers = new Headers(mergeTransportHeaders({
 			"content-type": "application/json",
 			"anthropic-version": "2023-06-01",
 			...params.apiKey ? { "x-api-key": params.apiKey } : {},
 			...params.authToken ? { authorization: `Bearer ${params.authToken}` } : {}
-		}, params.defaultHeaders);
+		}, params.defaultHeaders));
+		for (const [name, value] of Object.entries(options?.headers ?? {})) headers.set(name, value);
 		const response = await params.fetch(url, {
 			method: "POST",
 			headers,
@@ -499,18 +493,20 @@ function createAnthropicTransportClient(params) {
 	}
 	if (useAnthropicServerSideFallback(model)) betaFeatures.push(ANTHROPIC_SERVER_SIDE_FALLBACK_BETA);
 	const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: false });
+	const defaultHeaders = mergeTransportHeaders({
+		accept: "application/json",
+		"anthropic-dangerous-direct-browser-access": "true",
+		...betaHeader ? { "anthropic-beta": betaHeader } : {}
+	}, model.headers, options?.headers);
 	return {
 		client: createAnthropicMessagesClient({
 			apiKey,
 			baseURL: model.baseUrl,
-			defaultHeaders: mergeTransportHeaders({
-				accept: "application/json",
-				"anthropic-dangerous-direct-browser-access": "true",
-				...betaHeader ? { "anthropic-beta": betaHeader } : {}
-			}, model.headers, options?.headers),
+			defaultHeaders,
 			fetch
 		}),
-		isOAuthToken: false
+		isOAuthToken: false,
+		directApiKeyBetaHeader: isDirectAnthropicModel(model) ? new Headers(defaultHeaders).get("anthropic-beta") ?? "" : void 0
 	};
 }
 async function buildAnthropicParams(model, context, isOAuthToken, options) {
@@ -529,7 +525,6 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		cacheRetention: options?.cacheRetention,
 		enableCacheControl: true
 	}, model);
-	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
 	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
 		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
 		authProfileId: options?.authProfileId,
@@ -537,7 +532,6 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 	});
 	const messages = await convertAnthropicMessages(replayPlan.messages, model, isOAuthToken, {
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
-		cacheBreakpointOptOutMessageIndexes,
 		compaction: replayPlan.compaction,
 		replayThinkingEnabled
 	});
@@ -595,7 +589,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		const projectedToolChoice = toolProjection ? reconcileAnthropicToolChoice(normalizedToolChoice, toolProjection) : normalizedToolChoice;
 		if (projectedToolChoice) params.tool_choice = projectedToolChoice;
 	}
-	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, cacheBreakpointOptOutMessageIndexes);
+	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, /* @__PURE__ */ new Set());
 	return {
 		params,
 		toolProjection,
@@ -630,7 +624,9 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 		toolChoice: options?.toolChoice,
 		thinkingBudgets: options?.thinkingBudgets,
 		reasoning,
-		...options?.anthropicServerCompaction === true ? { anthropicServerCompaction: true } : {},
+		anthropicServerCompaction: options?.anthropicServerCompaction,
+		anthropicCompactThreshold: options?.anthropicCompactThreshold,
+		cacheTtlPruning: options?.cacheTtlPruning,
 		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
 	});
 	if (reasoning === "off") {
@@ -671,17 +667,18 @@ function createAnthropicMessagesTransportStreamFn() {
 				stopReason: "stop",
 				timestamp: Date.now()
 			};
-			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream, () => notifyLlmRequestActivity(options?.signal)) : void 0;
+			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream) : void 0;
 			const eventSink = refusalBuffer ?? stream;
 			let costModel = model;
 			let messageStartPromptUsage;
 			let usedCompactionReplay = false;
+			let inputTransformations;
 			try {
 				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
 				if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 				const transportOptions = resolveAnthropicTransportOptions(model, options, apiKey);
 				const requestContext = prepareClaudeNoPrefillRequestContext(model, context);
-				const { client, isOAuthToken } = createAnthropicTransportClient({
+				const { client, isOAuthToken, directApiKeyBetaHeader } = createAnthropicTransportClient({
 					model,
 					context: requestContext,
 					apiKey,
@@ -691,13 +688,19 @@ function createAnthropicMessagesTransportStreamFn() {
 				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 { response, stream: anthropicStream } = await client.messages.stream({
 					...params,
 					stream: true
-				}, transportOptions.signal ? { signal: transportOptions.signal } : void 0);
+				}, {
+					signal: transportOptions.signal,
+					headers: bindingHeaders
+				});
 				await notifyProviderHttpResponse({
 					options: transportOptions,
 					response,
@@ -812,6 +815,8 @@ function createAnthropicMessagesTransportStreamFn() {
 					});
 				};
 				for await (const event of anthropicStream) {
+					inputTransformations = readAnthropicInputTransformations(event) ?? inputTransformations;
+					notifyLlmRequestActivity(transportOptions.signal);
 					if (event.type === "error") {
 						const error = event.error;
 						throw new Error(error?.message || "Anthropic Messages stream failed");
@@ -1101,6 +1106,7 @@ function createAnthropicMessagesTransportStreamFn() {
 						continue;
 					}
 					if (event.type === "message_delta") {
+						logAnthropicContextEdits(event);
 						const delta = event.delta;
 						const usage = event.usage;
 						if (delta?.stop_reason) {
@@ -1149,6 +1155,8 @@ function createAnthropicMessagesTransportStreamFn() {
 						for (const block of output.content) delete block.index;
 					}
 				});
+			} finally {
+				logAnthropicThinkingDrops(inputTransformations);
 			}
 		})();
 		return eventStream;
@@ -1880,164 +1888,6 @@ function createOpenAICompletionsTransportStreamFn() {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-responses-compact-request.ts
-const COMPACT_REQUEST = Symbol("openaiResponsesCompactRequest");
-function claimResponsesCompactRequest(options) {
-	const controller = options ? Reflect.get(options, COMPACT_REQUEST) : void 0;
-	if (controller?.claimed === false) {
-		controller.claimed = true;
-		return controller;
-	}
-}
-/** Run a compact-endpoint request through the session's prepared stream stack. */
-async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context, options) {
-	const preparedOptions = { ...options };
-	let resolveResult;
-	let rejectResult;
-	const result = new Promise((resolve, reject) => {
-		resolveResult = resolve;
-		rejectResult = reject;
-	});
-	const controller = {
-		claimed: false,
-		resolve: resolveResult,
-		reject: rejectResult
-	};
-	Reflect.set(preparedOptions, COMPACT_REQUEST, controller);
-	const stream = await Promise.resolve(streamFn(model, context, preparedOptions));
-	if (!controller.claimed) throw new Error("Prepared stream did not reach an OpenAI Responses transport");
-	try {
-		return await result;
-	} finally {
-		await stream.result().catch(() => void 0);
-	}
-}
-//#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) {
-	return stableStringify(JSON.parse(JSON.stringify(left))) === stableStringify(JSON.parse(JSON.stringify(right)));
-}
-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 resolveResponsesContinuationRequest(continuation, request) {
-	if (!continuation) return {
-		request,
-		continuationStatus: "no_previous_response"
-	};
-	if (request.previous_response_id) return {
-		request,
-		continuationStatus: "explicit_previous_response_id"
-	};
-	if (!jsonValuesEqual(requestWithoutInput(request), requestWithoutInput(continuation.lastRequest))) return {
-		request,
-		continuationStatus: "request_changed"
-	};
-	const currentInput = request.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: {
-			...request,
-			previous_response_id: continuation.lastResponseId,
-			input: currentInput.slice(baselineLength)
-		},
-		continuationStatus: "continued"
-	};
-}
-const httpContinuationEntries = /* @__PURE__ */ new Map();
-let nextHttpContinuationGeneration = 1;
-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 generation = nextHttpContinuationGeneration++;
-	const claimed = {
-		kind: "claimed",
-		sessionId: params.sessionId,
-		generation
-	};
-	httpContinuationEntries.set(key, claimed);
-	return {
-		request: resolveResponsesContinuationRequest(previous?.kind === "ready" ? previous.state : void 0, params.request).request,
-		commit: (effectiveRequest, response) => {
-			if (httpContinuationEntries.get(key) !== claimed) return;
-			const idleTimer = setTimeout(() => {
-				const current = httpContinuationEntries.get(key);
-				if (current?.kind === "ready" && current.generation === generation) httpContinuationEntries.delete(key);
-			}, HTTP_CONTINUATION_IDLE_TTL_MS);
-			idleTimer.unref?.();
-			const ready = {
-				...claimed,
-				kind: "ready",
-				state: {
-					lastRequest: effectiveRequest,
-					lastResponseId: response.id,
-					lastResponseItems: response.output
-				},
-				idleTimer
-			};
-			httpContinuationEntries.set(key, ready);
-		},
-		release: () => {
-			if (httpContinuationEntries.get(key) === claimed) httpContinuationEntries.delete(key);
-		}
-	};
-}
-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-params-internal.ts
 const OPENAI_RESPONSES_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
 	"openai",
@@ -2065,10 +1915,6 @@ function convertResponsesTools(tools, model, options) {
 		})
 	};
 }
-function getPromptCacheRetention(baseUrl, cacheRetention) {
-	if (cacheRetention !== "long") return;
-	return baseUrl?.includes("api.openai.com") ? "24h" : void 0;
-}
 function resolveOpenAIReasoningEffort(options) {
 	return normalizeOpenAIReasoningEffort(options?.reasoningEffort ?? options?.reasoning ?? "high");
 }
@@ -2179,14 +2025,14 @@ function buildOpenAIResponsesParams(model, context, options, metadata, replayMod
 		input: messages,
 		stream: true,
 		prompt_cache_key: promptCacheKey,
-		prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
+		...resolveOpenAIResponsesCacheParams(model, cacheRetention, model.baseUrl?.includes("api.openai.com")),
 		...instructions ? { instructions } : {},
 		...metadata ? { metadata } : {}
 	};
 	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
-	if (effectiveMaxTokens) params.max_output_tokens = effectiveMaxTokens;
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (options?.topP !== void 0) params.top_p = options.topP;
+	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)
@@ -2231,6 +2077,308 @@ function buildOpenAIResponsesParams(model, context, options, metadata, replayMod
 	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 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 resolved = resolveResponsesContinuationRequest(previous?.kind === "ready" ? previous.state : void 0, params.request);
+		const fullRequest = resolved.fullRequest ?? params.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);
+	return JSON.parse(serialized);
+}
+async function projectResponsesSteeringInput(request, project) {
+	const { input: activeInput, ...activeSettings } = cloneWireRequest(request);
+	if (!Array.isArray(activeInput)) return [];
+	const { input, ...settings } = cloneWireRequest(await project());
+	if (!Array.isArray(input) || stableStringify(settings) !== stableStringify(activeSettings) || stableStringify(input.slice(0, activeInput.length)) !== stableStringify(activeInput)) return [];
+	const projected = input.slice(activeInput.length);
+	return projected.every((item) => isRecord(item) && item.role === "user") ? projected : [];
+}
+/** One response owns admission; accepted input stays on this connection until continuation. */
+function createResponsesSteering(params) {
+	let responseId;
+	let sealed = false;
+	let unsubscribe;
+	const pending = [];
+	const accepted = /* @__PURE__ */ new Map();
+	const acknowledged = /* @__PURE__ */ new Set();
+	const seal = () => {
+		sealed = true;
+		const cleanup = unsubscribe;
+		unsubscribe = void 0;
+		cleanup?.();
+	};
+	return {
+		get responseId() {
+			return responseId;
+		},
+		get pending() {
+			return pending.length > 0;
+		},
+		get acceptedInput() {
+			return [...accepted.values()].flat();
+		},
+		seal,
+		close(error) {
+			seal();
+			for (const submission of pending.splice(0)) submission.reject(error);
+		},
+		handle(event) {
+			if (!isRecord(event)) return false;
+			if (event.type === "response.created" && !responseId && !sealed) {
+				const response = isRecord(event.response) ? event.response : void 0;
+				if (typeof response?.id !== "string" || !response.id.trim()) throw new Error("Responses steering requires a response identity");
+				const activeResponseId = response.id;
+				responseId = activeResponseId;
+				const cleanup = params.onActiveResponse({
+					needsContinuation: params.needsContinuation,
+					steer(messages) {
+						if (sealed || messages.length === 0) return Promise.resolve(false);
+						params.assertActive();
+						const converted = params.toInput(messages);
+						const submit = (input) => {
+							if (sealed || input.length === 0) return Promise.resolve(false);
+							params.assertActive();
+							return new Promise((resolve, reject) => {
+								pending.push({
+									input,
+									resolve,
+									reject
+								});
+								params.send({
+									type: "response.steer",
+									previous_response_id: activeResponseId,
+									input
+								});
+							});
+						};
+						return Array.isArray(converted) ? submit(converted) : converted.then(submit);
+					}
+				});
+				if (sealed) cleanup?.();
+				else unsubscribe = cleanup;
+				return false;
+			}
+			if (event.type !== "response.steer.accepted" && event.type !== "response.steer.failed" && event.type !== "response.steer.pending") return false;
+			const steer = isRecord(event.steer) ? event.steer : void 0;
+			if (!responseId || steer?.previous_response_id !== responseId) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.failed" && steer.id === void 0) {
+				const index = pending.findIndex((submission) => stableStringify(submission.input) === stableStringify(steer.input));
+				const submission = pending[index];
+				if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+				pending.splice(index, 1);
+				submission.resolve(false);
+				return true;
+			}
+			if (typeof steer.id !== "string" || !steer.id.trim()) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.pending") {
+				if (!accepted.has(steer.id)) throw new Error("Responses steering pending event has no accepted submission");
+				return true;
+			}
+			if (event.type === "response.steer.failed" && accepted.has(steer.id)) throw new Error("OpenAI could not apply accepted steering; the queued message remains in the conversation");
+			if (acknowledged.has(steer.id)) throw new Error("Responses steering acknowledgement was already applied");
+			const submission = pending.shift();
+			if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+			acknowledged.add(steer.id);
+			if (event.type === "response.steer.accepted") {
+				accepted.set(steer.id, submission.input);
+				submission.resolve(true);
+			} else submission.resolve(false);
+			return true;
+		}
+	};
+}
+/** Accepted steering is prepended by the server, so never repeat it in response.create. */
+function omitAcceptedSteering(input, accepted) {
+	const remaining = [...input];
+	for (const message of accepted) {
+		const index = remaining.findIndex((item) => stableStringify(item) === stableStringify(message));
+		if (index < 0) throw new Error("Responses steering continuation no longer contains the accepted user input");
+		remaining.splice(index, 1);
+	}
+	return remaining;
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-websocket.ts
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
 const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
@@ -2263,6 +2411,9 @@ function invalidateOwnedWebSocketSession(cacheKey, entry, reason = "done") {
 		entry.idleTimer = void 0;
 	}
 	closeWebSocketSilently(entry.socket, reason);
+	entry.steeringContinuation?.steering.close(/* @__PURE__ */ new Error("Responses steering connection closed"));
+	entry.steeringContinuation?.iterator.return?.().catch(() => void 0);
+	entry.steeringContinuation = void 0;
 	if (websocketSessionCache.get(cacheKey) === entry) websocketSessionCache.delete(cacheKey);
 }
 function scheduleSessionWebSocketExpiry(cacheKey, entry) {
@@ -2312,11 +2463,14 @@ function createTransientWebSocketLease(connection) {
 }
 function createCachedWebSocketLease(cacheKey, entry, reusedConnection) {
 	entry.busy = true;
+	const steeringContinuation = entry.steeringContinuation;
+	entry.steeringContinuation = void 0;
 	return {
 		socket: entry.socket,
-		iterator: entry.socket.stream(),
+		iterator: steeringContinuation?.iterator ?? entry.socket.stream(),
 		entry,
 		reusedConnection,
+		steeringContinuation,
 		release: ({ keep } = {}) => {
 			if (!keep || entry.socket.socket.readyState !== WEBSOCKET_OPEN_STATE) {
 				invalidateOwnedWebSocketSession(cacheKey, entry);
@@ -2400,11 +2554,13 @@ function createOpenAIResponsesWebSocketStream(params) {
 		throw new OpenAIResponsesWebSocketPreDispatchError(error);
 	}
 	let prepared;
+	const resumedSteering = lease.steeringContinuation;
+	const steeringMode = resumedSteering ? resumedSteering.requiresInput ? "required-input" : "automatic" : void 0;
 	try {
 		const continuation = lease.entry?.continuation;
 		if (continuation && lease.entry) {
 			lease.entry.continuation = void 0;
-			prepared = resolveResponsesContinuationRequest(continuation, fullRequest);
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
 		} else prepared = {
 			request: fullRequest,
 			continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
@@ -2418,11 +2574,54 @@ function createOpenAIResponsesWebSocketStream(params) {
 	let terminalResponse;
 	let terminalReceived = false;
 	let released = false;
+	let retainIterator = false;
+	let deferredInput = false;
+	let inputReplay;
+	if (resumedSteering) try {
+		if (prepared.continuationStatus !== "continued" || !prepared.request.previous_response_id) throw new Error("Responses steering continuation changed its request or history");
+		const input = omitAcceptedSteering(prepared.request.input ?? [], resumedSteering.acceptedInput);
+		if (!resumedSteering.requiresInput && (stableStringify(fullRequest.instructions) !== stableStringify(resumedSteering.instructions) || stableStringify(fullRequest.tools) !== stableStringify(resumedSteering.tools))) throw new Error("Responses automatic steering continuation cannot change instructions or tools");
+		const baseline = prepared.fullRequest ?? fullRequest;
+		const priorLength = (baseline.input?.length ?? 0) - (prepared.request.input?.length ?? 0);
+		const fingerprints = input.map(responsesInputFingerprint);
+		if (fingerprints.length > 0) inputReplay = {
+			afterResponseId: prepared.request.previous_response_id,
+			before: resumedSteering.requiresInput ? fingerprints : [],
+			after: resumedSteering.requiresInput ? [] : fingerprints
+		};
+		const delivered = resumedSteering.requiresInput ? input : [];
+		prepared.fullRequest = {
+			...baseline,
+			input: [
+				...(baseline.input ?? []).slice(0, priorLength),
+				...resumedSteering.acceptedInput,
+				...delivered
+			]
+		};
+		prepared.request = {
+			...prepared.request,
+			input: delivered
+		};
+		deferredInput = !resumedSteering.requiresInput && input.length > 0;
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw new OpenAIResponsesWebSocketPostDispatchError(error);
+	}
+	const steering = lease.entry && params.onActiveResponse && params.steeringInput ? createResponsesSteering({
+		onActiveResponse: params.onActiveResponse,
+		toInput: params.steeringInput,
+		send: (event) => lease.socket.sendRaw(JSON.stringify(event)),
+		needsContinuation: () => deferredInput,
+		assertActive: () => {
+			if (released || terminalReceived || params.signal?.aborted) throw new Error("Responses steering is no longer active");
+		}
+	}) : void 0;
 	const finish = ({ keep = true } = {}) => {
 		if (released) return;
 		released = true;
 		if (keep && lease.entry && terminalResponse) lease.entry.continuation = {
-			lastRequest: fullRequest,
+			lastRequest: prepared.fullRequest ?? fullRequest,
 			lastResponseId: terminalResponse.id,
 			lastResponseItems: terminalResponse.output
 		};
@@ -2436,8 +2635,19 @@ function createOpenAIResponsesWebSocketStream(params) {
 			let requestDispatched = false;
 			try {
 				if (params.signal?.aborted) throw transportAbortError(params.signal);
+				if (resumedSteering) {
+					requestDispatched = true;
+					if (resumedSteering.requiresInput) lease.socket.send({
+						...prepared.request,
+						type: "response.create"
+					});
+				}
 				for (;;) {
-					const next = await nextWebSocketMessage(iterator, params.signal);
+					const buffered = resumedSteering?.buffered.shift();
+					const next = buffered ? {
+						value: buffered,
+						done: false
+					} : await nextWebSocketMessage(iterator, params.signal);
 					if (next.done) throw new Error("OpenAI Responses WebSocket closed before a terminal response event");
 					if (next.value.type === "open") {
 						if (!requestDispatched) {
@@ -2451,8 +2661,51 @@ function createOpenAIResponsesWebSocketStream(params) {
 					}
 					const event = readServerEvent(next.value);
 					if (!event) continue;
+					if (isRecord(event) && typeof event.type === "string" && event.type.startsWith("response.steer.")) {
+						if ((isRecord(event.steer) && event.steer.previous_response_id === steering?.responseId ? steering : resumedSteering?.steering ?? steering)?.handle(event)) continue;
+					}
+					steering?.handle(event);
 					if (event.type === "response.completed") terminalResponse = event.response;
 					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
+					if (terminalReceived) {
+						steering?.seal();
+						if (event.type === "response.failed") steering?.close(/* @__PURE__ */ new Error("Responses failed before steering could be applied"));
+						const continuationBuffer = [];
+						for (;;) {
+							if (!steering?.pending) break;
+							const acknowledgement = await nextWebSocketMessage(iterator, params.signal);
+							if (acknowledgement.done) throw new Error("Responses closed before acknowledging steering");
+							const acknowledgedEvent = readServerEvent(acknowledgement.value);
+							if (!steering.handle(acknowledgedEvent)) continuationBuffer.push(acknowledgement.value);
+						}
+						const acceptedInput = steering?.acceptedInput ?? [];
+						const isSteered = event.type === "response.incomplete" && isRecord(event.response.incomplete_details) && event.response.incomplete_details.reason === "steered";
+						if (lease.entry && steering && acceptedInput.length > 0 && (event.type === "response.completed" || isSteered)) {
+							if (event.type === "response.incomplete") terminalResponse = event.response;
+							lease.entry.steeringContinuation = {
+								iterator,
+								buffered: continuationBuffer,
+								acceptedInput,
+								requiresInput: (terminalResponse?.output ?? []).some((item) => (item.type === "function_call" || item.type === "custom_tool_call") && !(isRecord(item) && item.async === true) || item.type === "mcp_approval_request"),
+								steering,
+								instructions: fullRequest.instructions,
+								tools: fullRequest.tools
+							};
+							retainIterator = true;
+							if (isSteered) {
+								yield {
+									...event,
+									type: "response.completed",
+									response: {
+										...event.response,
+										status: "completed",
+										incomplete_details: null
+									}
+								};
+								return;
+							}
+						}
+					}
 					yield event;
 					if (terminalReceived) {
 						degradedWebSocketConnections.delete(degradationKey);
@@ -2460,20 +2713,27 @@ function createOpenAIResponsesWebSocketStream(params) {
 					}
 				}
 			} catch (error) {
+				const steeringDispatched = Boolean(steering?.pending || steering?.acceptedInput.length || resumedSteering);
+				steering?.close(error instanceof Error ? error : /* @__PURE__ */ new Error("Responses steering failed"));
 				if (lease.entry) lease.entry.continuation = void 0;
-				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError;
+				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError && !steeringDispatched;
 				if (!params.callerSignal?.aborted && !safeRetry) markDegraded();
 				if (!requestDispatched && !params.signal?.aborted) throw new OpenAIResponsesWebSocketPreDispatchError(error);
 				if (!requestDispatched || params.callerSignal?.aborted || safeRetry) throw error;
 				throw new OpenAIResponsesWebSocketPostDispatchError(error);
 			} finally {
-				await iterator.return?.().catch(() => void 0);
+				steering?.seal();
+				if (!retainIterator) {
+					steering?.close(/* @__PURE__ */ new Error("Responses stream ended before steering was confirmed"));
+					await iterator.return?.().catch(() => void 0);
+				}
 				if (!terminalReceived) finish({ keep: false });
 			}
 		} },
 		request: prepared.request,
 		reusedConnection: lease.reusedConnection,
 		continuationStatus: prepared.continuationStatus,
+		inputReplay,
 		finish
 	};
 }
@@ -2486,6 +2746,70 @@ function closeOpenAIResponsesWebSocketSessions(sessionId) {
 }
 registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
 //#endregion
+//#region packages/ai/src/transports/openai-responses-compact-client.ts
+async function postOpenAIResponsesCompaction(params) {
+	const compactInput = typeof params.request.instructions === "string" && params.request.instructions.length > 0 ? [buildOpenAIResponsesCompactSystemMessage(params.model, params.request.instructions), ...params.request.input ?? []] : params.request.input;
+	const response = await params.client.post("/responses/compact", {
+		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, { timeoutMs: params.options?.timeoutMs }),
+		body: {
+			model: params.request.model,
+			input: compactInput
+		}
+	});
+	const output = isRecord(response) && Array.isArray(response.output) ? response.output : [];
+	const item = output.at(-1);
+	const retainedItems = output.slice(0, -1);
+	const retainedUserMessageCount = retainedItems.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user" && Array.isArray(candidate.content)).length;
+	const inputUserMessageCount = Array.isArray(params.request.input) ? params.request.input.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user").length : 0;
+	const retainedMessagePrefixSupported = supportsNativeOpenAIResponsesEndpoint(params.model);
+	const usage = isRecord(response) && isRecord(response.usage) ? response.usage : void 0;
+	if (!isRecord(response) || response.object !== "response.compaction" || !isOpenAIResponsesCompactionOutput(output, params.model) || retainedItems.length > 0 && (!retainedMessagePrefixSupported || retainedUserMessageCount !== inputUserMessageCount) || !isRecord(item) || item.type !== "compaction" || typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0 || !usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") throw new Error("Responses compact endpoint did not return one trailing compaction item");
+	return {
+		output,
+		item,
+		historyMode: retainedUserMessageCount > 0 ? "retained-users" : "compacted-prefix",
+		usage,
+		model: params.model,
+		replayMetadata: buildOpenAIResponsesReasoningReplayMetadata(params.model, {
+			authProfileId: params.options?.authProfileId,
+			sessionId: params.options?.sessionId
+		})
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-compact-request.ts
+const COMPACT_REQUEST = Symbol("openaiResponsesCompactRequest");
+function claimResponsesCompactRequest(options) {
+	const controller = options ? Reflect.get(options, COMPACT_REQUEST) : void 0;
+	if (controller?.claimed === false) {
+		controller.claimed = true;
+		return controller;
+	}
+}
+/** Run a compact-endpoint request through the session's prepared stream stack. */
+async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context, options) {
+	const preparedOptions = { ...options };
+	let resolveResult;
+	let rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	const controller = {
+		claimed: false,
+		resolve: resolveResult,
+		reject: rejectResult
+	};
+	Reflect.set(preparedOptions, COMPACT_REQUEST, controller);
+	const stream = await Promise.resolve(streamFn(model, context, preparedOptions));
+	if (!controller.claimed) throw new Error("Prepared stream did not reach an OpenAI Responses transport");
+	try {
+		return await result;
+	} finally {
+		await stream.result().catch(() => void 0);
+	}
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-client.ts
 function resolveNativeOpenAIResponsesWebSocketMode(model, transport) {
 	if (transport !== "websocket" && transport !== "websocket-cached" && transport !== "auto") return;
@@ -2529,35 +2853,6 @@ function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turn
 		...buildOpenAISdkClientOptions(model)
 	});
 }
-async function postOpenAIResponsesCompaction(params) {
-	const compactInput = typeof params.request.instructions === "string" && params.request.instructions.length > 0 ? [buildOpenAIResponsesCompactSystemMessage(params.model, params.request.instructions), ...params.request.input ?? []] : params.request.input;
-	const response = await params.client.post("/responses/compact", {
-		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, { timeoutMs: params.options?.timeoutMs }),
-		body: {
-			model: params.request.model,
-			input: compactInput
-		}
-	});
-	const output = isRecord(response) && Array.isArray(response.output) ? response.output : [];
-	const item = output.at(-1);
-	const retainedItems = output.slice(0, -1);
-	const retainedUserMessageCount = retainedItems.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user" && Array.isArray(candidate.content)).length;
-	const inputUserMessageCount = Array.isArray(params.request.input) ? params.request.input.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user").length : 0;
-	const retainedMessagePrefixSupported = supportsNativeOpenAIResponsesEndpoint(params.model);
-	const usage = isRecord(response) && isRecord(response.usage) ? response.usage : void 0;
-	if (!isRecord(response) || response.object !== "response.compaction" || !isOpenAIResponsesCompactionOutput(output, params.model) || retainedItems.length > 0 && (!retainedMessagePrefixSupported || retainedUserMessageCount !== inputUserMessageCount) || !isRecord(item) || item.type !== "compaction" || typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0 || !usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") throw new Error("Responses compact endpoint did not return one trailing compaction item");
-	return {
-		output,
-		item,
-		historyMode: retainedUserMessageCount > 0 ? "retained-users" : "compacted-prefix",
-		usage,
-		model: params.model,
-		replayMetadata: buildOpenAIResponsesReasoningReplayMetadata(params.model, {
-			authProfileId: params.options?.authProfileId,
-			sessionId: params.options?.sessionId
-		})
-	};
-}
 function createResponsesTransportExecutor(config) {
 	return (model, context, options) => {
 		const responsesOptions = options;
@@ -2579,8 +2874,10 @@ function createResponsesTransportExecutor(config) {
 				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 buildRequest = async (replayMode) => {
-					let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata, replayMode);
+				const nativeAstra = model.id === "gpt-6-astra" && supportsNativeOpenAIResponsesEndpoint(model);
+				const asyncToolExecutionEligible = nativeAstra && options?.asyncToolExecution === true && !responsesOptions?.openclawCodeModeToolSurface;
+				const prepareRequest = async (request) => {
+					let params = request;
 					const nextParams = await options?.onPayload?.(params, model);
 					if (nextParams !== void 0) params = nextParams;
 					if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
@@ -2592,9 +2889,15 @@ function createResponsesTransportExecutor(config) {
 						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
 						assertCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
 					}
+					if (asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true && params.tools) params.tools = params.tools.map((tool) => tool.type === "function" ? {
+						...tool,
+						async: true
+					} : tool);
 					return params;
 				};
-				const params = await buildRequest("checkpoint");
+				const buildRequest = (replayMode, requestContext = context) => prepareRequest(config.buildRequest(model, requestContext, responsesOptions, turnState?.metadata, replayMode));
+				let params = await buildRequest("checkpoint");
+				const asyncTools = asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true;
 				if (compactRequest) {
 					const compacted = await postOpenAIResponsesCompaction({
 						client,
@@ -2618,13 +2921,16 @@ function createResponsesTransportExecutor(config) {
 					provider: model.provider,
 					api: model.api,
 					baseUrl: model.baseUrl
-				}) && sessionId && params.store === true && !params.previous_response_id) continuationClaim = claimOpenAIResponsesHttpContinuation({
-					sessionId,
-					apiKey,
-					baseUrl: model.baseUrl,
-					headers: buildOpenAIClientHeaders(model, context, options?.headers, turnState?.headers, sessionId),
-					request: params
-				});
+				}) && 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),
+						request: params
+					});
+					if (continuationClaim) params = continuationClaim.fullRequest;
+				}
 				const observePrompt = createResponsesPromptEgressObserver(responsesOptions, context.systemPrompt);
 				const requestStartedAt = Date.now();
 				let started = false;
@@ -2693,9 +2999,15 @@ function createResponsesTransportExecutor(config) {
 						headers: websocketHeaders,
 						signal: websocketSignal,
 						callerSignal: options?.signal,
-						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs
+						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]
+						}))
 					});
 					finishWebSocket = websocket.finish;
+					recordResponsesInputReplay(output, websocket.inputReplay);
 					observePrompt?.(websocket.request, {
 						egress: "responses-websocket",
 						payloadVariant: "initial"
@@ -2737,7 +3049,8 @@ function createResponsesTransportExecutor(config) {
 							yield* await createSseStream();
 						}
 					} };
-				} catch {
+				} catch (error) {
+					if (error instanceof OpenAIResponsesWebSocketPostDispatchError) throw error;
 					closeWebSocketForFallback("setup_failure");
 					responseStream = await createSseStream();
 				}
@@ -2752,7 +3065,8 @@ function createResponsesTransportExecutor(config) {
 						reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
 							authProfileId: responsesOptions?.authProfileId,
 							sessionId: options?.sessionId
-						})
+						}),
+						asyncToolExecution: asyncTools
 					});
 					finishWebSocket?.();
 					if (options?.signal?.aborted) throw transportAbortError(options.signal);
@@ -3275,4 +3589,4 @@ function prepareModelForSimpleCompletion(params) {
 	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
 }
 //#endregion
-export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicCacheControlToMessages, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, 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, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, 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, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicCacheControlToMessages, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, 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, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };