@openclaw/ai 2026.9.1 → 2026.9.3

package/dist/transports.mjs

@@ -1,30 +1,34 @@
-import { g as supportsClaudeAdaptiveThinking, m as resolveClaudeSonnet5ModelIdentity, p as resolveClaudeOpus5ModelIdentity, y as supportsClaudeNativeXhighEffort } from "./src-C8U7lkoa.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 { 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 { _ as supportsClaudeAdaptiveThinking, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-B2Q_6G8V.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 { 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-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 { 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-Cu3ZPhNW.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 { 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 { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-BuSUaAk5.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 { 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-tApyTLVu.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
 import { ResponsesWS } from "openai/resources/responses/ws.js";
@@ -59,11 +63,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 ?? ""));
 }
@@ -82,224 +81,12 @@ function buildAnthropicBetaHeader(model, betaFeatures, params) {
 	if (!isDirectAnthropicModel(model)) return;
 	return params.oauth ? `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}` : betaFeatures.join(",");
 }
-const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
-async function convertContentBlocks(content, model, imageBudget) {
-	const text = extractToolResultText(content);
-	const mediaPlaceholder = describeToolResultMediaPlaceholder(content);
-	if (!(model.input.includes("image") && content.some(isImageWithMediaPayload))) return sanitizeNonEmptyTransportPayloadText(text, mediaPlaceholder ?? "(no output)");
-	const blocks = [];
-	let hasTextBlock = false;
-	for (const block of content) {
-		if (!block || typeof block !== "object") continue;
-		const record = block;
-		const blockText = extractToolResultBlockText(block);
-		if (blockText) {
-			blocks.push({
-				type: "text",
-				text: sanitizeTransportPayloadText(blockText)
-			});
-			hasTextBlock = true;
-		}
-		if (!isImageWithMediaPayload(record)) continue;
-		const [normalizedImage] = await normalizeAnthropicInlineContent([{
-			type: "image",
-			data: typeof record.data === "string" ? record.data : "",
-			mimeType: typeof record.mimeType === "string" ? record.mimeType : "image/png"
-		}], imageBudget);
-		if (normalizedImage?.type !== "image") continue;
-		blocks.push({
-			type: "image",
-			source: {
-				type: "base64",
-				media_type: resolveAnthropicImageMediaType(normalizedImage.mimeType),
-				data: normalizedImage.data
-			}
-		});
-	}
-	if (!hasTextBlock) blocks.unshift({
-		type: "text",
-		text: mediaPlaceholder ?? "(see attached image)"
-	});
-	return blocks;
-}
-async function convertAnthropicMessages(messages, model, isOAuthToken, options) {
-	const params = [];
-	const imageBudget = createAnthropicInlineImageBudget();
-	const allowReasoningContentReplay = options.allowReasoningContentReplay === true;
-	const replayThinkingEnabled = options.replayThinkingEnabled !== false;
-	const transformedMessages = transformTransportMessages(messages, model, normalizeAnthropicToolCallId);
-	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
-	for (let i = 0; i < transformedMessages.length; i += 1) {
-		const msg = transformedMessages[i];
-		if (!msg) continue;
-		if (msg.role === "user") {
-			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;
-			}
-			const blocks = (model.input.includes("image") ? await normalizeAnthropicInlineContent(msg.content, imageBudget) : msg.content.map((item) => item.type === "image" ? {
-				type: "text",
-				text: NON_VISION_USER_IMAGE_PLACEHOLDER
-			} : item)).map((item) => item.type === "text" ? {
-				type: "text",
-				text: sanitizeTransportPayloadText(item.text)
-			} : {
-				type: "image",
-				source: {
-					type: "base64",
-					media_type: resolveAnthropicImageMediaType(item.mimeType),
-					data: item.data
-				}
-			});
-			let filteredBlocks = model.input.includes("image") ? blocks : blocks.filter((block) => block.type !== "image");
-			filteredBlocks = filteredBlocks.filter((block) => block.type !== "text" || block.text.trim().length > 0);
-			if (filteredBlocks.length === 0) continue;
-			const userParam = {
-				role: "user",
-				content: filteredBlocks
-			};
-			if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
-			params.push(userParam);
-			continue;
-		}
-		if (msg.role === "assistant") {
-			const blocks = i === 0 && options.compaction ? [options.compaction] : [];
-			const reasoningContent = [];
-			let omittedThinking = false;
-			for (const block of msg.content) {
-				if (block.type === "text") {
-					if (block.text.trim().length > 0) blocks.push({
-						type: "text",
-						text: sanitizeTransportPayloadText(block.text)
-					});
-					continue;
-				}
-				if (block.type === "thinking") {
-					const thinkingSignature = block.thinkingSignature?.trim();
-					const isReasoningContent = thinkingSignature === "reasoning_content";
-					if (!replayThinkingEnabled && i !== activeToolTurnAssistantIndex && !isReasoningContent) {
-						omittedThinking = true;
-						continue;
-					}
-					if (block.redacted) {
-						blocks.push({
-							type: "redacted_thinking",
-							data: block.thinkingSignature
-						});
-						continue;
-					}
-					const hasNativeThinkingSignature = Boolean(thinkingSignature) && !isReasoningContent;
-					if (block.thinking.trim().length === 0 && !hasNativeThinkingSignature) continue;
-					if (!thinkingSignature) blocks.push({
-						type: "text",
-						text: sanitizeTransportPayloadText(block.thinking)
-					});
-					else {
-						const thinking = thinkingSignature === "reasoning_content" ? sanitizeTransportPayloadText(block.thinking) : block.thinking;
-						if (thinkingSignature === "reasoning_content") {
-							if (allowReasoningContentReplay) {
-								blocks.push({
-									type: "thinking",
-									thinking,
-									signature: thinkingSignature
-								});
-								reasoningContent.push(thinking);
-							}
-							continue;
-						}
-						blocks.push({
-							type: "thinking",
-							thinking,
-							signature: thinkingSignature
-						});
-					}
-					continue;
-				}
-				if (block.type === "toolCall") blocks.push({
-					type: "tool_use",
-					id: block.id,
-					name: isOAuthToken ? toClaudeCodeToolName(block.name) : block.name,
-					input: coerceTransportToolCallArguments(block.arguments)
-				});
-			}
-			if (blocks.length === 0 && omittedThinking) blocks.push({
-				type: "text",
-				text: ANTHROPIC_OMITTED_REASONING_TEXT
-			});
-			if (blocks.length > 0) {
-				const assistantMsg = {
-					role: "assistant",
-					content: blocks
-				};
-				if (reasoningContent.length > 0) assistantMsg.reasoning_content = reasoningContent.join("\n");
-				else if (allowReasoningContentReplay) blocks.unshift({
-					type: "thinking",
-					thinking: "",
-					signature: "reasoning_content"
-				});
-				params.push(assistantMsg);
-			}
-			continue;
-		}
-		if (msg.role === "toolResult") {
-			const toolResult = msg;
-			const toolResults = [{
-				type: "tool_result",
-				tool_use_id: toolResult.toolCallId,
-				content: await convertContentBlocks(toolResult.content, model, imageBudget),
-				is_error: toolResult.isError
-			}];
-			let j = i + 1;
-			while (j < transformedMessages.length) {
-				const nextMsg = transformedMessages.at(j);
-				if (nextMsg?.role !== "toolResult") break;
-				toolResults.push({
-					type: "tool_result",
-					tool_use_id: nextMsg.toolCallId,
-					content: await convertContentBlocks(nextMsg.content, model, imageBudget),
-					is_error: nextMsg.isError
-				});
-				j += 1;
-			}
-			i = j - 1;
-			params.push({
-				role: "user",
-				content: toolResults
-			});
-		}
-	}
-	return params;
-}
 function ensureNonEmptyAnthropicMessages(messages) {
 	return messages.length > 0 ? messages : [{
 		role: "user",
 		content: EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT
 	}];
 }
-function convertAnthropicTools(tools, isOAuthToken) {
-	const projection = projectAnthropicTools(tools ?? [], (name) => isOAuthToken ? toClaudeCodeToolName(name) : name);
-	const converted = [];
-	for (const tool of projection.tools) converted.push({
-		name: tool.wireName,
-		description: tool.description,
-		input_schema: tool.inputSchema
-	});
-	return {
-		projection,
-		tools: converted
-	};
-}
-function parseAnthropicToolCallArguments(inputJson) {
-	return coerceTransportToolCallArguments(parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson));
-}
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 /** Resolve the effective Anthropic API base URL from model or environment. */
 function resolveAnthropicBaseUrl(baseUrl) {
@@ -402,12 +189,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,
@@ -421,7 +209,7 @@ function createAnthropicMessagesClient(params) {
 	} } };
 }
 function formatAnthropicMessagesHttpError(response, detail) {
-	const retryAfterSeconds = parseRetryAfterSeconds(response.headers);
+	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}`;
 }
@@ -440,6 +228,7 @@ async function readAnthropicMessagesErrorBodySnippet(response) {
 }
 function createAnthropicTransportClient(params) {
 	const { model, context, apiKey, options } = params;
+	const optionHeaders = resolveOpencodeSessionHeaders(model, options);
 	const needsInterleavedBeta = (options?.interleavedThinking ?? true) && !supportsClaudeAdaptiveThinking(model);
 	const fetch = isKimiAnthropicProvider(model.provider) && options?.thinkingEnabled === true ? buildGuardedModelFetch(model, void 0, { sanitizeSse: false }) : buildGuardedModelFetch(model);
 	if (model.provider === "github-copilot") {
@@ -453,7 +242,7 @@ function createAnthropicTransportClient(params) {
 					accept: "application/json",
 					"anthropic-dangerous-direct-browser-access": "true",
 					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
-				}, model.headers, getAiTransportHost().buildCopilotDynamicHeaders(context.messages), options?.headers),
+				}, model.headers, getAiTransportHost().buildCopilotDynamicHeaders(context.messages), optionHeaders),
 				fetch
 			}),
 			isOAuthToken: false
@@ -470,7 +259,7 @@ function createAnthropicTransportClient(params) {
 					accept: "application/json",
 					"anthropic-dangerous-direct-browser-access": "true",
 					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
-				}, omitFoundryBearerCredentialHeaders(model.headers), options?.headers),
+				}, omitFoundryBearerCredentialHeaders(model.headers), optionHeaders),
 				fetch
 			}),
 			isOAuthToken: false
@@ -491,7 +280,7 @@ function createAnthropicTransportClient(params) {
 					...betaHeader ? { "anthropic-beta": betaHeader } : {},
 					"user-agent": `claude-cli/${ANTHROPIC_CLAUDE_CODE_VERSION}`,
 					"x-app": "cli"
-				}, model.headers, options?.headers),
+				}, model.headers, optionHeaders),
 				fetch
 			}),
 			isOAuthToken: true
@@ -499,45 +288,39 @@ 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, optionHeaders);
 	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) {
-	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
-	const replayThinkingEnabled = mandatoryAdaptiveThinking || options?.thinkingEnabled === true;
+	const replayThinkingEnabled = requiresClaudeAdaptiveThinking(model) || options?.thinkingEnabled === true;
 	const maxTokens = resolveAnthropicMessagesMaxTokens({
 		modelContextWindow: model.contextWindow,
 		modelMaxTokens: model.maxTokens,
 		requestedMaxTokens: options?.maxTokens
 	});
 	if (maxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
-	const payloadPolicy = resolveAnthropicPayloadPolicy({
-		provider: model.provider,
-		api: model.api,
-		baseUrl: model.baseUrl,
-		cacheRetention: options?.cacheRetention,
-		enableCacheControl: true
-	}, model);
-	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
+	const { cacheControl, supportsCacheControlOnTools } = resolveAnthropicCacheOptions(model, options?.cacheRetention);
 	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
 		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
 		authProfileId: options?.authProfileId,
 		sessionId: options?.sessionId
 	});
-	const messages = await convertAnthropicMessages(replayPlan.messages, model, isOAuthToken, {
+	const messages = await convertAnthropicMessages(transformTransportMessages(replayPlan.messages, model, normalizeAnthropicToolCallId), model, isOAuthToken, {
+		profile: "transport",
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
-		cacheBreakpointOptOutMessageIndexes,
 		compaction: replayPlan.compaction,
 		replayThinkingEnabled
 	});
@@ -548,54 +331,18 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		stream: true
 	};
 	if (!isOAuthToken && useAnthropicServerSideFallback(model)) params.fallbacks = ANTHROPIC_SERVER_SIDE_FALLBACKS;
-	if (isOAuthToken) params.system = [
-		{
-			type: "text",
-			text: ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK
-		},
-		{
-			type: "text",
-			text: "You are Claude Code, Anthropic's official CLI for Claude."
-		},
-		...context.systemPrompt ? [{
-			type: "text",
-			text: sanitizeTransportPayloadText(context.systemPrompt)
-		}] : []
-	];
-	else if (context.systemPrompt) params.system = [{
-		type: "text",
-		text: sanitizeTransportPayloadText(context.systemPrompt)
-	}];
-	if (options?.temperature !== void 0 && !options.thinkingEnabled && !supportsClaudeNativeXhighEffort(model)) params.temperature = options.temperature;
-	if (options?.stop !== void 0 && options.stop.length > 0) params.stop_sequences = options.stop;
-	let toolProjection;
-	if (context.tools) {
-		const convertedTools = convertAnthropicTools(context.tools, isOAuthToken);
-		toolProjection = convertedTools.projection;
-		if (convertedTools.tools.length > 0) params.tools = convertedTools.tools;
-	}
-	if (mandatoryAdaptiveThinking || model.reasoning || supportsClaudeAdaptiveThinking(model)) {
-		if (mandatoryAdaptiveThinking || options?.thinkingEnabled) {
-			if (supportsClaudeAdaptiveThinking(model)) {
-				params.thinking = {
-					type: "adaptive",
-					display: options?.thinkingDisplay ?? "summarized"
-				};
-				const effort = options?.effort ?? (mandatoryAdaptiveThinking ? "high" : void 0);
-				if (effort) params.output_config = { effort };
-			} else params.thinking = {
-				type: "enabled",
-				budget_tokens: options?.thinkingBudgetTokens ?? 1024
-			};
-		} else if (options?.thinkingEnabled === false) params.thinking = { type: "disabled" };
-	}
-	if (options?.metadata && typeof options.metadata.user_id === "string") params.metadata = { user_id: options.metadata.user_id };
-	if (options?.toolChoice) {
-		const normalizedToolChoice = normalizeAnthropicToolChoice(replayThinkingEnabled, options.toolChoice);
-		const projectedToolChoice = toolProjection ? reconcileAnthropicToolChoice(normalizedToolChoice, toolProjection) : normalizedToolChoice;
-		if (projectedToolChoice) params.tool_choice = projectedToolChoice;
-	}
-	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, cacheBreakpointOptOutMessageIndexes);
+	const system = buildAnthropicSystemBlocks(context.systemPrompt, isOAuthToken, cacheControl);
+	if (system) params.system = system;
+	const convertedTools = context.tools ? convertAnthropicTools(context.tools, isOAuthToken) : void 0;
+	const toolProjection = convertedTools?.projection;
+	Object.assign(params, buildAnthropicGenerationParams({
+		model,
+		options,
+		tools: convertedTools?.tools,
+		toolProjection,
+		profile: "transport"
+	}));
+	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools);
 	return {
 		params,
 		toolProjection,
@@ -630,7 +377,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") {
@@ -661,27 +410,15 @@ function createAnthropicMessagesTransportStreamFn() {
 		const options = rawOptions;
 		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
-			const output = {
-				role: "assistant",
-				content: [],
-				api: "anthropic-messages",
-				provider: model.provider,
-				model: model.id,
-				usage: createEmptyTransportUsage(),
-				stopReason: "stop",
-				timestamp: Date.now()
-			};
-			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream, () => notifyLlmRequestActivity(options?.signal)) : void 0;
-			const eventSink = refusalBuffer ?? stream;
-			let costModel = model;
-			let messageStartPromptUsage;
+			const output = createAssistantOutput(model, "anthropic-messages");
+			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream) : void 0;
 			let usedCompactionReplay = false;
 			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 +428,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,
@@ -707,429 +450,17 @@ function createAnthropicMessagesTransportStreamFn() {
 					const detail = await readAnthropicMessagesErrorBodySnippet(response);
 					throw new Error(formatAnthropicMessagesHttpError(response, detail));
 				}
-				const blocks = output.content;
-				const blockIndexes = /* @__PURE__ */ new Map();
-				const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
-				const sealedToolCalls = [];
-				const compactionCapture = createCompactionCapture(output, model, transportOptions);
-				const pendingThinkingSignatures = /* @__PURE__ */ new Map();
-				const allowReasoningContentReplay = supportsReasoningContentReplay(model);
-				const reasoningContentThinkingBlocks = /* @__PURE__ */ new Map();
-				const reasoningContentTextBlocks = /* @__PURE__ */ new Map();
-				let sawMessageStop = false;
-				const pendingTextEnds = [];
-				const flushPendingTextEnds = () => {
-					for (const event of pendingTextEnds) eventSink.push(event);
-					pendingTextEnds.length = 0;
-				};
-				const eventIndexKey = (eventIndex) => typeof eventIndex === "number" ? eventIndex : -1;
-				const appendReasoningContentThinkingDelta = (eventIndex, rawText) => {
-					if (typeof rawText !== "string") return false;
-					const text = sanitizeTransportPayloadText(rawText);
-					if (text.length === 0) return false;
-					const key = eventIndexKey(eventIndex);
-					let contentIndex = reasoningContentThinkingBlocks.get(key);
-					let block = contentIndex === void 0 ? void 0 : output.content[contentIndex];
-					if (!block || block.type !== "thinking") {
-						block = {
-							type: "thinking",
-							thinking: "",
-							thinkingSignature: "reasoning_content"
-						};
-						output.content.push(block);
-						contentIndex = output.content.length - 1;
-						reasoningContentThinkingBlocks.set(key, contentIndex);
-						eventSink.push({
-							type: "thinking_start",
-							contentIndex,
-							partial: output
-						});
-					}
-					if (contentIndex === void 0) return false;
-					block.thinking += text;
-					block.thinkingSignature = "reasoning_content";
-					eventSink.push({
-						type: "thinking_delta",
-						contentIndex,
-						delta: text,
-						partial: output
-					});
-					return true;
-				};
-				const appendReasoningContentTextDelta = (eventIndex, rawText) => {
-					if (typeof rawText !== "string") return false;
-					const text = sanitizeTransportPayloadText(rawText);
-					if (text.length === 0) return false;
-					const key = eventIndexKey(eventIndex);
-					let contentIndex = reasoningContentTextBlocks.get(key);
-					let block = contentIndex === void 0 ? void 0 : output.content[contentIndex];
-					if (!block || block.type !== "text") {
-						block = {
-							type: "text",
-							text: ""
-						};
-						output.content.push(block);
-						contentIndex = output.content.length - 1;
-						reasoningContentTextBlocks.set(key, contentIndex);
-						eventSink.push({
-							type: "text_start",
-							contentIndex,
-							partial: output
-						});
-					}
-					if (contentIndex === void 0) return false;
-					block.text += text;
-					eventSink.push({
-						type: "text_delta",
-						contentIndex,
-						delta: text,
-						partial: output
-					});
-					return true;
-				};
-				const finishReasoningContentSidecars = (eventIndex) => {
-					const key = eventIndexKey(eventIndex);
-					const thinkingContentIndex = reasoningContentThinkingBlocks.get(key);
-					if (thinkingContentIndex !== void 0) {
-						reasoningContentThinkingBlocks.delete(key);
-						const block = output.content[thinkingContentIndex];
-						if (block?.type === "thinking") eventSink.push({
-							type: "thinking_end",
-							contentIndex: thinkingContentIndex,
-							content: block.thinking,
-							partial: output
-						});
-					}
-					const textContentIndex = reasoningContentTextBlocks.get(key);
-					if (textContentIndex === void 0) return;
-					reasoningContentTextBlocks.delete(key);
-					const block = output.content[textContentIndex];
-					if (block?.type === "text") eventSink.push({
-						type: "text_end",
-						contentIndex: textContentIndex,
-						content: block.text,
-						partial: output
-					});
-				};
-				for await (const event of anthropicStream) {
-					if (event.type === "error") {
-						const error = event.error;
-						throw new Error(error?.message || "Anthropic Messages stream failed");
-					}
-					if (event.type === "message_start") {
-						const message = event.message;
-						const usage = message?.usage ?? {};
-						output.responseId = typeof message?.id === "string" ? message.id : void 0;
-						output.responseModel = typeof message?.model === "string" ? message.model : void 0;
-						messageStartPromptUsage = applyAnthropicMessageStartUsage(output.usage, usage);
-						calculateCost(costModel, output.usage);
-						eventSink.push({
-							type: "start",
-							partial: output
-						});
-						continue;
-					}
-					if (event.type === "message_stop") {
-						sawMessageStop = true;
-						continue;
-					}
-					if (event.type === "content_block_start") {
-						const contentBlock = event.content_block;
-						const index = typeof event.index === "number" ? event.index : -1;
-						if (transportOptions.anthropicServerCompaction === true && compactionCapture.begin(index, contentBlock, output.content.length)) continue;
-						const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(contentBlock) : null;
-						if (fallbackBoundary) {
-							refusalBuffer?.discard();
-							sealedToolCalls.length = 0;
-							pendingTextEnds.length = 0;
-							blockIndexes.clear();
-							pendingThinkingSignatures.clear();
-							applyAnthropicFallbackBoundary({
-								output,
-								boundary: fallbackBoundary,
-								provider: model.provider
-							});
-							costModel = {
-								...model,
-								cost: resolveAnthropicFallbackServingModelCost({
-									requestedModelId: model.id,
-									servingModelId: fallbackBoundary.toModel,
-									requestedCost: model.cost
-								})
-							};
-							calculateCost(costModel, output.usage);
-							eventSink.push({
-								type: "start",
-								partial: output
-							});
-							for (const [i, block] of output.content.entries()) {
-								if (block.type !== "text") continue;
-								delete block.index;
-								eventSink.push({
-									type: "text_start",
-									contentIndex: i,
-									partial: output
-								});
-								if (block.text) eventSink.push({
-									type: "text_delta",
-									contentIndex: i,
-									delta: block.text,
-									partial: output
-								});
-								pendingTextEnds.push({
-									type: "text_end",
-									contentIndex: i,
-									content: block.text,
-									partial: output
-								});
-							}
-							continue;
-						}
-						pendingThinkingSignatures.delete(index);
-						if (contentBlock?.type === "text") {
-							const text = typeof contentBlock.text === "string" ? sanitizeTransportPayloadText(contentBlock.text) : "";
-							const block = {
-								type: "text",
-								text,
-								index
-							};
-							output.content.push(block);
-							const contentIndex = output.content.length - 1;
-							blockIndexes.set(index, contentIndex);
-							eventSink.push({
-								type: "text_start",
-								contentIndex,
-								partial: output
-							});
-							if (text.length > 0) eventSink.push({
-								type: "text_delta",
-								contentIndex,
-								delta: text,
-								partial: output
-							});
-							continue;
-						}
-						if (contentBlock?.type === "thinking") {
-							const thinking = typeof contentBlock.thinking === "string" ? contentBlock.thinking : "";
-							const block = {
-								type: "thinking",
-								thinking,
-								thinkingSignature: typeof contentBlock.signature === "string" ? contentBlock.signature : "",
-								index
-							};
-							output.content.push(block);
-							const contentIndex = output.content.length - 1;
-							blockIndexes.set(index, contentIndex);
-							eventSink.push({
-								type: "thinking_start",
-								contentIndex,
-								partial: output
-							});
-							if (thinking.length > 0) eventSink.push({
-								type: "thinking_delta",
-								contentIndex,
-								delta: thinking,
-								partial: output
-							});
-							continue;
-						}
-						if (contentBlock?.type === "redacted_thinking") {
-							const block = {
-								type: "thinking",
-								thinking: "[Reasoning redacted]",
-								thinkingSignature: typeof contentBlock.data === "string" ? contentBlock.data : "",
-								redacted: true,
-								index
-							};
-							output.content.push(block);
-							blockIndexes.set(index, output.content.length - 1);
-							eventSink.push({
-								type: "thinking_start",
-								contentIndex: output.content.length - 1,
-								partial: output
-							});
-							continue;
-						}
-						if (contentBlock?.type === "tool_use") {
-							tagPendingCommentaryText(output.content);
-							flushPendingTextEnds();
-							const block = {
-								type: "toolCall",
-								id: typeof contentBlock.id === "string" ? contentBlock.id : "",
-								name: typeof contentBlock.name === "string" ? isOAuthToken ? resolveOriginalAnthropicToolName(contentBlock.name, toolProjection) : contentBlock.name : "",
-								arguments: contentBlock.input && typeof contentBlock.input === "object" ? contentBlock.input : {},
-								partialJson: "",
-								index
-							};
-							output.content.push(block);
-							blockIndexes.set(index, output.content.length - 1);
-							toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
-							eventSink.push({
-								type: "toolcall_start",
-								contentIndex: output.content.length - 1,
-								partial: output
-							});
-						}
-						continue;
-					}
-					if (event.type === "content_block_delta") {
-						const delta = event.delta;
-						const eventIndex = typeof event.index === "number" ? event.index : void 0;
-						if (eventIndex !== void 0 && compactionCapture.delta(eventIndex, delta)) continue;
-						let index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
-						let block = index === void 0 ? void 0 : blocks[index];
-						if (allowReasoningContentReplay) {
-							const appendedThinking = appendReasoningContentThinkingDelta(event.index, delta?.reasoning_content);
-							const hasNativeAnthropicDelta = delta?.type === "text_delta" && typeof delta.text === "string" || delta?.type === "thinking_delta" && typeof delta.thinking === "string" || delta?.type === "input_json_delta" && typeof delta.partial_json === "string" || delta?.type === "signature_delta" && typeof delta.signature === "string";
-							let appendedContent = false;
-							if (!hasNativeAnthropicDelta && typeof delta?.content === "string" && delta.content.length > 0) {
-								const text = sanitizeTransportPayloadText(delta.content);
-								if (text.length > 0) {
-									if (block?.type === "text" && index !== void 0) {
-										block.text += text;
-										eventSink.push({
-											type: "text_delta",
-											contentIndex: index,
-											delta: text,
-											partial: output
-										});
-										appendedContent = true;
-									} else appendedContent = appendReasoningContentTextDelta(event.index, text);
-								}
-							}
-							if ((appendedThinking || appendedContent) && !hasNativeAnthropicDelta) continue;
-						}
-						if (!block && delta?.type === "text_delta" && typeof delta.text === "string") {
-							block = {
-								type: "text",
-								text: "",
-								index: typeof event.index === "number" ? event.index : blocks.length
-							};
-							output.content.push(block);
-							index = output.content.length - 1;
-							if (typeof event.index === "number") blockIndexes.set(event.index, index);
-							eventSink.push({
-								type: "text_start",
-								contentIndex: index,
-								partial: output
-							});
-						}
-						if (index === void 0) continue;
-						if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
-							block.text += delta.text;
-							eventSink.push({
-								type: "text_delta",
-								contentIndex: index,
-								delta: delta.text,
-								partial: output
-							});
-							continue;
-						}
-						if (block?.type === "thinking" && delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
-							block.thinking += delta.thinking;
-							eventSink.push({
-								type: "thinking_delta",
-								contentIndex: index,
-								delta: delta.thinking,
-								partial: output
-							});
-							continue;
-						}
-						if (block?.type === "toolCall" && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
-							const partialJson = `${block.partialJson ?? ""}${delta.partial_json}`;
-							block.partialJson = partialJson;
-							if (toolArgumentPreviewSchedules.get(block)?.(partialJson.length)) block.arguments = parseAnthropicToolCallArguments(partialJson);
-							eventSink.push({
-								type: "toolcall_delta",
-								contentIndex: index,
-								delta: delta.partial_json,
-								partial: output
-							});
-							continue;
-						}
-						if (block?.type === "thinking" && delta?.type === "signature_delta" && typeof delta.signature === "string") {
-							const signatureIndex = eventIndexKey(event.index);
-							const pendingSignature = pendingThinkingSignatures.get(signatureIndex);
-							if (pendingSignature === void 0) {
-								block.thinkingSignature = "";
-								pendingThinkingSignatures.set(signatureIndex, delta.signature);
-							} else pendingThinkingSignatures.set(signatureIndex, pendingSignature + delta.signature);
-						}
-						continue;
-					}
-					if (event.type === "content_block_stop") {
-						const eventIndex = typeof event.index === "number" ? event.index : void 0;
-						if (eventIndex !== void 0 && compactionCapture.complete(eventIndex)) continue;
-						const pendingSignature = eventIndex === void 0 ? void 0 : pendingThinkingSignatures.get(eventIndex);
-						if (eventIndex !== void 0) pendingThinkingSignatures.delete(eventIndex);
-						const index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
-						const block = index === void 0 ? void 0 : blocks[index];
-						if (eventIndex === void 0 || index === void 0 || !block) {
-							finishReasoningContentSidecars(event.index);
-							continue;
-						}
-						blockIndexes.delete(eventIndex);
-						delete block.index;
-						if (block.type === "text") {
-							pendingTextEnds.push({
-								type: "text_end",
-								contentIndex: index,
-								content: block.text,
-								partial: output
-							});
-							finishReasoningContentSidecars(event.index);
-							continue;
-						}
-						if (block.type === "thinking") {
-							if (pendingSignature !== void 0) block.thinkingSignature = pendingSignature;
-							eventSink.push({
-								type: "thinking_end",
-								contentIndex: index,
-								content: block.thinking,
-								partial: output
-							});
-							finishReasoningContentSidecars(event.index);
-							continue;
-						}
-						if (block.type === "toolCall") {
-							sealedToolCalls.push({
-								block,
-								contentIndex: index
-							});
-							finishReasoningContentSidecars(event.index);
-						}
-						continue;
-					}
-					if (event.type === "message_delta") {
-						const delta = event.delta;
-						const usage = event.usage;
-						if (delta?.stop_reason) {
-							if (delta.stop_reason === "refusal") applyAnthropicRefusal(output, delta.stop_details, model.provider);
-							else output.stopReason = mapAnthropicStopReason(delta.stop_reason);
-						}
-						applyAnthropicMessageDeltaUsage(output.usage, usage, messageStartPromptUsage);
-						calculateCost(costModel, output.usage);
-						if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
-						flushPendingTextEnds();
-					}
-				}
-				if (isDirectAnthropicModel(model) && !sawMessageStop) throw new Error("Anthropic stream ended before message_stop");
-				if (transportOptions.signal?.aborted) throw transportAbortError(transportOptions.signal);
-				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
-				if ([...blockIndexes.values()].some((index) => blocks[index]?.type === "toolCall")) throw new Error("Provider completed stream with an incomplete tool call");
-				finalizeTerminalToolCallArguments(sealedToolCalls.map(({ block }) => block), (block) => block.partialJson && block.partialJson.length > 0 ? block.partialJson : block.arguments);
-				for (const sealed of sealedToolCalls) {
-					delete sealed.block.partialJson;
-					eventSink.push({
-						type: "toolcall_end",
-						contentIndex: sealed.contentIndex,
-						toolCall: sealed.block,
-						partial: output
-					});
-				}
-				refusalBuffer?.flush();
-				if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
-				flushPendingTextEnds();
+				await consumeAnthropicStream({
+					events: anthropicStream,
+					model,
+					options: transportOptions,
+					output,
+					stream,
+					refusalBuffer,
+					isOAuthToken,
+					toolProjection,
+					profile: "transport"
+				});
 				finalizeTransportStream({
 					stream,
 					output
@@ -1155,63 +486,6 @@ function createAnthropicMessagesTransportStreamFn() {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/model-max-tokens-params.ts
-/**
-* Max-token parameter normalization across provider/native naming variants.
-* Callers canonicalize aliases before dispatch so payloads cannot carry
-* conflicting limits.
-*/
-const MAX_TOKENS_PARAM_KEYS = [
-	"maxTokens",
-	"max_completion_tokens",
-	"max_tokens"
-];
-/** Resolve the first supported max-token parameter present in a params object. */
-function resolveMaxTokensParam(params) {
-	if (!params) return;
-	for (const key of MAX_TOKENS_PARAM_KEYS) {
-		const resolved = asNonNegativeFiniteNumber(params[key]);
-		if (resolved !== void 0) return resolved;
-	}
-}
-/**
-* Canonicalize merged params to `maxTokens`, preserving source precedence from
-* left to right across the provided source objects.
-*/
-function canonicalizeMaxTokensParam(params) {
-	let resolved;
-	for (const source of params.sources) {
-		const sourceValue = resolveMaxTokensParam(source);
-		if (sourceValue !== void 0) resolved = sourceValue;
-	}
-	if (resolved === void 0) return;
-	for (const key of MAX_TOKENS_PARAM_KEYS) delete params.merged[key];
-	params.merged.maxTokens = resolved;
-}
-//#endregion
-//#region packages/ai/src/transports/model-transport-url.ts
-/**
-* Debug formatting helpers for model transport endpoints.
-* Keeps logs useful without exposing credentials, request params, or fragments.
-*/
-/** Return a sanitized URL suitable for logs and diagnostics. */
-function formatModelTransportDebugUrl(rawUrl) {
-	try {
-		const parsed = new URL(rawUrl);
-		parsed.username = "";
-		parsed.password = "";
-		parsed.search = "";
-		parsed.hash = "";
-		return parsed.toString();
-	} catch {
-		return "<invalid-url>";
-	}
-}
-/** Format a configured base URL for debug output, or the implicit default. */
-function formatModelTransportDebugBaseUrl(rawUrl) {
-	return rawUrl ? formatModelTransportDebugUrl(rawUrl) : "default";
-}
-//#endregion
 //#region packages/ai/src/transports/openai-compatible-conversation-turn.ts
 /**
 * OpenAI-compatible conversation turn detector.
@@ -1248,488 +522,44 @@ function hasOpenAICompatibleConversationTurn(messages) {
 	});
 }
 //#endregion
-//#region packages/ai/src/transports/openai-completions-string-content.ts
-/**
-* OpenAI Chat Completions compatibility helpers. Some providers only accept
-* role/content messages with plain string content instead of text block arrays.
-*/
-function flattenStringOnlyCompletionContent(content) {
-	if (!Array.isArray(content)) return content;
-	const textParts = [];
-	for (const item of content) {
-		if (!item || typeof item !== "object" || item.type !== "text" || typeof item.text !== "string") return content;
-		textParts.push(item.text);
-	}
-	return textParts.join("\n");
-}
-/** Flatten string-only text block content arrays into newline-joined strings. */
-function flattenCompletionMessagesToStringContent(messages) {
-	return messages.map((message) => {
-		if (!message || typeof message !== "object") return message;
-		const content = message.content;
-		const flattenedContent = flattenStringOnlyCompletionContent(content);
-		if (flattenedContent === content) return message;
-		return {
-			...message,
-			content: flattenedContent
-		};
-	});
-}
-/** Strip completion messages to role/content fields for strict providers. */
-function stripCompletionMessagesToRoleContent(messages) {
-	return messages.map((message) => {
-		if (!message || typeof message !== "object" || Array.isArray(message)) return message;
-		const record = message;
-		const stripped = {};
-		if (Object.hasOwn(record, "role")) stripped.role = record.role;
-		if (Object.hasOwn(record, "content")) stripped.content = record.content;
-		return stripped;
-	});
-}
-//#endregion
-//#region packages/ai/src/transports/openai-completions-host.ts
-/**
-* Chat Completions accepts Azure AI Foundry hosts in addition to traditional
-* Azure OpenAI hosts. Do not replace this with isTraditionalAzureOpenAIHost,
-* which intentionally excludes the .services.ai.azure.com Foundry suffix.
-*/
-function isAzureOpenAICompatibleHost(hostname) {
-	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+//#region packages/ai/src/transports/openai-completions-transport.ts
+function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
+	const messages = params.messages;
+	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
+	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
 }
-//#endregion
-//#region packages/ai/src/transports/openai-completions-replay.ts
-function isGoogleOpenAICompatModel(model) {
-	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
-	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
-}
-function requiresGoogleCompatToolCallThoughtSignature(model) {
-	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
-}
-const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
-const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
-function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
-	return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
-}
-function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
-	if (!isGoogleOpenAICompatModel(model)) return;
-	const sigById = /* @__PURE__ */ new Map();
-	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
-	for (const msg of context.messages ?? []) {
-		if (msg.role !== "assistant") continue;
-		const source = msg;
-		if (!Array.isArray(source.content)) continue;
-		for (const block of source.content) {
-			if (block.type !== "toolCall") continue;
-			const id = block.id;
-			const sig = block.thoughtSignature;
-			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
-				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
-				if (!isSameRoute && !fallbackSig) continue;
-				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
-			}
-		}
-	}
-	if (sigById.size === 0 && !fallbackSig) return;
-	for (const message of outgoingMessages) {
-		const toolCalls = message.tool_calls;
-		if (!Array.isArray(toolCalls)) continue;
-		for (const toolCall of toolCalls) {
-			const id = toolCall.id;
-			if (typeof id !== "string") continue;
-			let sig = sigById.get(id) ?? fallbackSig;
-			if (typeof sig === "string" && sig.length > 0) {
-				if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
+const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
+const SSE_DONE_MAX_LINE_CHARS = 1024;
+function createSseDoneDetector() {
+	const decoder = new TextDecoder();
+	let line = "";
+	let lineOverflowed = false;
+	let sawDone = false;
+	const finishLine = () => {
+		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
+		line = "";
+		lineOverflowed = false;
+	};
+	const observeText = (text) => {
+		for (const char of text) {
+			if (char === "\n" || char === "\r") {
+				finishLine();
+				continue;
 			}
-			if (typeof sig !== "string" || sig.length === 0) continue;
-			const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
-			toolCall.extra_content = extra;
-			const google = extra.google && typeof extra.google === "object" ? extra.google : {};
-			extra.google = google;
-			google.thought_signature = sig;
+			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
+			else lineOverflowed = true;
 		}
-	}
-}
-const COMPLETIONS_REASONING_REPLAY_FIELDS = [
-	"reasoning_details",
-	"reasoning_content",
-	"reasoning",
-	"reasoning_text"
-];
-function stripCompletionsReasoningReplayFields(record) {
-	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
-}
-function sanitizeOpenRouterReasoningReplayFields(record) {
-	const reasoningDetails = record.reasoning_details;
-	if (typeof reasoningDetails === "string") {
-		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
-		delete record.reasoning_details;
-	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
-	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
-	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
-	const reasoningText = record.reasoning_text;
-	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
-	if ("reasoning_text" in record) delete record.reasoning_text;
-}
-function sanitizeReasoningContentReplayFields(record) {
-	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
-	delete record.reasoning_details;
-	delete record.reasoning;
-	delete record.reasoning_text;
-}
-const REASONING_CONTENT_REPLAY_MODEL_IDS = /* @__PURE__ */ new Set([
-	"deepseek-v4-flash",
-	"deepseek-v4-pro",
-	"kimi-for-coding",
-	"kimi-k2.5",
-	"kimi-k2.6",
-	"kimi-k2.7-code",
-	"kimi-k2.7-code-highspeed",
-	"kimi-k3",
-	"kimi-k2-thinking",
-	"kimi-k2-thinking-turbo",
-	"mimo-v2-pro",
-	"mimo-v2-omni",
-	"mimo-v2.5",
-	"mimo-v2.5-pro",
-	"mimo-v2.6-pro"
-]);
-const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
-	"-free",
-	"-paid",
-	"-trial"
-];
-function stripReasoningContentReplayTierSuffix(modelId) {
-	for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
-	return modelId;
-}
-function getReasoningContentReplayModelIdCandidates(modelId) {
-	if (typeof modelId !== "string") return [];
-	const normalized = modelId.trim().toLowerCase();
-	if (!normalized) return [];
-	const parts = normalized.split("/").filter(Boolean);
-	const finalPart = parts[parts.length - 1] ?? normalized;
-	const candidates = [finalPart];
-	const colonParts = finalPart.split(":").filter(Boolean);
-	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
-	const baseCount = candidates.length;
-	for (let index = 0; index < baseCount; index += 1) {
-		const candidate = candidates[index];
-		if (typeof candidate !== "string") continue;
-		const stripped = stripReasoningContentReplayTierSuffix(candidate);
-		if (stripped !== candidate) candidates.push(stripped);
-	}
-	return uniqueStrings(candidates.filter(Boolean));
-}
-function shouldPreserveReasoningContentReplay(model, compat) {
-	if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
-	return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
-}
-function shouldPreserveOpenRouterReasoningReplay(model) {
-	if (model.provider !== "openrouter") return true;
-	const normalizedModelId = model.id.trim().toLowerCase();
-	return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
-}
-function shouldTrustReasoningContentReplayMetadata(model) {
-	if (!model.reasoning) return false;
-	if (model.provider.trim().toLowerCase() === "openai") return false;
-	return shouldPreserveOpenRouterReasoningReplay(model);
-}
-function sanitizeCompletionsReasoningReplayFields(messages, options) {
-	if (!Array.isArray(messages)) return;
-	for (const msg of messages) {
-		if (!msg || typeof msg !== "object") continue;
-		const record = msg;
-		if (record.role !== "assistant") continue;
-		if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
-		else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
-		else stripCompletionsReasoningReplayFields(record);
-	}
-}
-function applyCompletionsReplay(outgoingMessages, context, model, compat) {
-	injectToolCallThoughtSignatures(outgoingMessages, context, model);
-	sanitizeCompletionsReasoningReplayFields(outgoingMessages, {
-		preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
-		preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
-	});
-}
-//#endregion
-//#region packages/ai/src/transports/openai-completions-params.ts
-function isKnownOpenAICompletionsEndpoint(model) {
-	if (!model.baseUrl.trim()) return true;
-	const endpointClass = resolveProviderEndpoint(model).endpointClass;
-	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
-	try {
-		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
-	} catch {
-		return false;
-	}
-}
-function resolveOpenAICompletionsReasoningEffort(options) {
-	return options?.reasoningEffort ?? options?.reasoning ?? "high";
-}
-function resolveOpenAICompletionsMaxTokens(model, options) {
-	if (options?.maxTokens) return {
-		maxTokens: options.maxTokens,
-		clampToModelMaxTokens: true
-	};
-	const paramsMaxTokens = resolveMaxTokensParam(model.params);
-	if (paramsMaxTokens) return {
-		maxTokens: paramsMaxTokens,
-		clampToModelMaxTokens: false
 	};
 	return {
-		maxTokens: model.maxTokens,
-		clampToModelMaxTokens: false
-	};
-}
-function resolveOpenAICompletionsModelMaxTokens(model) {
-	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
-}
-const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
-const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
-function estimateOpenAICompletionsInputTokens(payload) {
-	let adjustedChars = 0;
-	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
-	if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
-		adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
-	} catch {
-		adjustedChars += 1024;
-	}
-	if (payload.response_format !== void 0) try {
-		adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
-	} catch {
-		adjustedChars += 256;
-	}
-	return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
-}
-function estimateOpenAICompletionsMessagesChars(messages) {
-	if (!Array.isArray(messages)) return 0;
-	let adjustedChars = 0;
-	for (const message of messages) {
-		if (!message || typeof message !== "object") continue;
-		const record = message;
-		adjustedChars += estimateOpenAICompletionsContentChars(record.content);
-		for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
-		if (record.tool_calls !== void 0) try {
-			adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
-		} catch {
-			adjustedChars += 256;
-		}
-	}
-	return adjustedChars;
-}
-function estimateOpenAICompletionsContentChars(value) {
-	if (typeof value === "string") return estimateStringChars(value);
-	if (!Array.isArray(value)) return 0;
-	let adjustedChars = 0;
-	for (const block of value) {
-		if (!block || typeof block !== "object") continue;
-		const record = block;
-		if (record.type === "image_url" || record.type === "input_image") {
-			adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
-			continue;
-		}
-		const text = record.text;
-		if (typeof text === "string") {
-			adjustedChars += estimateStringChars(text);
-			continue;
-		}
-		try {
-			adjustedChars += estimateStringChars(JSON.stringify(block));
-		} catch {
-			adjustedChars += 256;
-		}
-	}
-	return adjustedChars;
-}
-function resolveOpenAICompletionsEffectiveContextTokens(model) {
-	const contextTokens = model.contextTokens;
-	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
-	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
-}
-function isQwenOpenAICompletionsThinkingFormat(format) {
-	return format === "qwen" || format === "qwen-chat-template";
-}
-function setQwenChatTemplateThinking(params, enabled) {
-	const existing = params.chat_template_kwargs;
-	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
-		...existing,
-		enable_thinking: enabled
-	} : { enable_thinking: enabled };
-}
-function applyQwenOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
-	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
-	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
-	else params.payload.enable_thinking = enabled;
-	return true;
-}
-function applyTogetherOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return;
-	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
-}
-function convertTools(tools, compat, model) {
-	const projection = projectOpenAITools(tools);
-	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
-		transport: "stream",
-		supportsStrictMode: compat?.supportsStrictMode
-	}), {
-		transport: "completions",
-		model
-	});
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const functionTool = {
-				name: tool.name,
-				description: tool.description,
-				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
-			};
-			if (strict !== void 0) functionTool.strict = strict;
-			return {
-				type: "function",
-				function: functionTool
-			};
-		})
-	};
-}
-function buildOpenAICompletionsParams(model, context, options) {
-	const compat = getCompat(model);
-	const compatDetection = detectOpenAICompletionsCompat(model);
-	const completionsContext = context.systemPrompt ? {
-		...context,
-		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
-	} : context;
-	let messages = convertMessages(model, completionsContext, compat);
-	applyCompletionsReplay(messages, context, model, compat);
-	if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
-	const params = {
-		model: model.id,
-		messages: compat.requiresStringContent ? flattenCompletionMessagesToStringContent(messages) : messages,
-		stream: true
-	};
-	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
-	if (compat.supportsStore) params.store = false;
-	if (compat.supportsPromptCacheKey && promptCacheKey) {
-		params.prompt_cache_key = promptCacheKey;
-		if (cacheRetention === "long" && compat.supportsLongCacheRetention) params.prompt_cache_retention = "24h";
-	}
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (options?.topP !== void 0) params.top_p = options.topP;
-	const responseFormat = resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
-		provider: model.provider,
-		baseUrl: model.baseUrl,
-		hasTools: () => Boolean(context.tools?.length)
-	}) ? void 0 : options?.responseFormat, compat.supportsJsonSchemaResponseFormat);
-	if (responseFormat !== void 0) params.response_format = responseFormat;
-	if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
-	if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
-	if (options?.seed !== void 0) params.seed = options.seed;
-	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
-	if (supportsModelTools(model)) {
-		if (context.tools) {
-			const converted = convertTools(context.tools, compat, model);
-			if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
-			else if (hasToolCallHistory(context.messages)) params.tools = [];
-			if (options?.toolChoice) {
-				const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, converted.projection);
-				if (toolChoice !== void 0) params.tool_choice = toolChoice;
-			} else if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
-		} else if (hasToolCallHistory(context.messages)) params.tools = [];
-		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
-			delete params.tools;
-			delete params.tool_choice;
-		}
-	}
-	{
-		const maxTokenBudget = resolveOpenAICompletionsMaxTokens(model, options);
-		const effectiveMaxTokens = maxTokenBudget.maxTokens;
-		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
-		let clampedMaxTokens = effectiveMaxTokens;
-		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
-		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
-			clampedMaxTokens = modelMaxTokens;
-			emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
-		}
-		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
-			const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
-			const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
-			if (clampedMaxTokens > remainingBudget) {
-				clampedMaxTokens = remainingBudget;
-				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
-			}
-		}
-		if (clampedMaxTokens) {
-			if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
-			else params.max_completion_tokens = clampedMaxTokens;
-		}
-	}
-	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
-	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
-		model,
-		effort: completionsReasoningEffort,
-		fallbackMap: compat.reasoningEffortMap
-	}) : void 0;
-	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
-	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
-	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	applyTogetherOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
-	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
-	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
-	return params;
-}
-//#endregion
-//#region packages/ai/src/transports/openai-completions-transport.ts
-function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
-	const messages = params.messages;
-	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
-	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
-}
-const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
-const SSE_DONE_MAX_LINE_CHARS = 1024;
-function createSseDoneDetector() {
-	const decoder = new TextDecoder();
-	let line = "";
-	let lineOverflowed = false;
-	let sawDone = false;
-	const finishLine = () => {
-		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
-		line = "";
-		lineOverflowed = false;
-	};
-	const observeText = (text) => {
-		for (const char of text) {
-			if (char === "\n" || char === "\r") {
-				finishLine();
-				continue;
-			}
-			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
-			else lineOverflowed = true;
-		}
-	};
-	return {
-		observe(chunk) {
-			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
-		},
-		finish() {
-			if (sawDone) return;
-			observeText(decoder.decode());
-			if (line || lineOverflowed) finishLine();
-		},
-		sawDone: () => sawDone
+		observe(chunk) {
+			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
+		},
+		finish() {
+			if (sawDone) return;
+			observeText(decoder.decode());
+			if (line || lineOverflowed) finishLine();
+		},
+		sawDone: () => sawDone
 	};
 }
 function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, opts) {
@@ -1823,7 +653,7 @@ function createOpenAICompletionsTransportStreamFn() {
 						statusText: response.statusText
 					});
 				};
-				const client = createOpenAICompletionsClient(model, context, apiKey, options?.headers, { fetch: doneDetectingFetch });
+				const client = createOpenAICompletionsClient(model, context, apiKey, resolveOpencodeSessionHeaders(model, options), { fetch: doneDetectingFetch });
 				let params = buildOpenAICompletionsParams(model, context, options);
 				const nextParams = await options?.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
@@ -1880,164 +710,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",
@@ -2045,30 +717,6 @@ const OPENAI_RESPONSES_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
 	"azure-openai-responses",
 	"github-copilot"
 ]);
-function convertResponsesTools(tools, model, options) {
-	const projection = projectOpenAITools(tools);
-	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, options?.strict, {
-		transport: "responses",
-		model
-	});
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const result = {
-				type: "function",
-				name: tool.name,
-				description: tool.description,
-				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
-			};
-			if (strict !== void 0) result.strict = strict;
-			return result;
-		})
-	};
-}
-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");
 }
@@ -2101,6 +749,7 @@ const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
 	"max_output_tokens",
 	"metadata",
 	"prompt_cache_retention",
+	"prompt_cache_options",
 	"service_tier",
 	"temperature",
 	"top_p"
@@ -2116,6 +765,7 @@ function stripOpenAICodexResponsesUnsupportedTextFields(params) {
 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;
 }
@@ -2151,84 +801,399 @@ function resolveOpenAIResponsesTextFormat(responseFormat) {
 		...responseFormat.json_schema,
 		type: "json_schema"
 	};
-	return responseFormat;
+	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"
+	};
 }
-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
-	});
+const httpContinuationEntries = /* @__PURE__ */ new Map();
+function deleteHttpContinuationIfOwned(key, entry) {
+	if (httpContinuationEntries.get(key) === entry) httpContinuationEntries.delete(key);
 }
-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 promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
-	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
-	const params = {
-		model: model.id,
-		input: messages,
-		stream: true,
-		prompt_cache_key: promptCacheKey,
-		prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
-		...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 (options?.responseFormat !== void 0) params.text = {
-		...params.text,
-		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+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
 	};
-	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
-	if (context.tools) {
-		const converted = convertResponsesTools(context.tools, model, { strict: resolveOpenAIStrictToolSetting(model, { transport: "stream" }) });
-		if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
-		if (options?.toolChoice) {
-			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, converted.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" }
+	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)
 				};
-				if (reasoningEffort !== "none") params.include = ["reasoning.encrypted_content"];
+				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;
 			}
-		} else if (model.provider !== "github-copilot") {
-			const reasoningEffort = resolveOpenAIReasoningEffortForModel({
-				model,
-				effort: "none"
-			});
-			if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
+			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);
 	}
-	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
-	return sanitizeOpenAICodexResponsesParams(model, params);
+	return remaining;
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-websocket.ts
@@ -2263,6 +1228,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 +1280,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);
@@ -2378,7 +1349,7 @@ function readServerEvent(message) {
 }
 function createOpenAIResponsesWebSocketStream(params) {
 	const connection = prepareWebSocketConnection(params.client, params.headers);
-	const fullRequest = sanitizeWebSocketRequest(params.request);
+	let fullRequest = sanitizeWebSocketRequest(params.request);
 	const requestModel = typeof fullRequest.model === "string" ? fullRequest.model : "";
 	const degradationKey = `${params.sessionId ?? ""}\0${connection.identity}\0${requestModel}`;
 	const degraded = degradedWebSocketConnections.get(degradationKey);
@@ -2400,15 +1371,20 @@ 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);
-		} else prepared = {
-			request: fullRequest,
-			continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
-		};
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
+		} else {
+			fullRequest = params.restoreRequest?.(fullRequest) ?? fullRequest;
+			prepared = {
+				request: fullRequest,
+				continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
+			};
+		}
 	} catch (error) {
 		lease.iterator.return?.().catch(() => void 0);
 		lease.release({ keep: false });
@@ -2418,11 +1394,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 +1455,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 +1481,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 +1533,28 @@ 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,
+		fullRequest: prepared.fullRequest ?? fullRequest,
 		reusedConnection: lease.reusedConnection,
 		continuationStatus: prepared.continuationStatus,
+		inputReplay,
 		finish
 	};
 }
@@ -2486,6 +1567,123 @@ 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-reasoning-state.ts
+function inputReplay(message) {
+	const value = "openclawResponsesInputReplay" in message ? message.openclawResponsesInputReplay : void 0;
+	return isRecord(value) ? value : void 0;
+}
+/** Save only admitted settings and hashes, never another copy of the conversation. */
+function recordResponsesReasoningState(message, model, identity, request, output) {
+	if (!supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || message.providerReplay || output.some((item) => isRecord(item) && item.type === "compaction")) return;
+	const reasoning = {
+		...buildProviderReplayContext(model, identity),
+		effort: request.reasoning.effort,
+		controls: request.input.flatMap((item, index) => isConfigurationUpdate(item) ? [{
+			index,
+			item
+		}] : []),
+		inputLength: request.input.length,
+		outputLength: output.length,
+		prefixHash: responsesContinuationPrefixFingerprint(request.input, output),
+		requestHash: responsesContinuationRequestFingerprint(request)
+	};
+	Object.assign(message, { openclawResponsesInputReplay: {
+		...inputReplay(message),
+		reasoning
+	} });
+}
+/** A cold transport can replay controls, but cannot resurrect a server response handle. */
+function restoreResponsesReasoningState(context, model, identity, request) {
+	const latest = context.messages.findLast((message) => message.role === "assistant");
+	const state = latest ? inputReplay(latest)?.reasoning : void 0;
+	if (!isRecord(state)) return request;
+	const { effort, inputLength, outputLength, controls, prefixHash, requestHash } = state;
+	if (!isOpenAIResponsesReplayContext(state) || !providerReplayContextMatches(state, buildProviderReplayContext(model, identity)) || latest?.providerReplay || !supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || request.input.some(isConfigurationUpdate) || typeof effort !== "string" || typeof inputLength !== "number" || !Number.isSafeInteger(inputLength) || inputLength < 0 || typeof outputLength !== "number" || !Number.isSafeInteger(outputLength) || outputLength < 0 || !Array.isArray(controls) || controls.length > inputLength || inputLength + outputLength > request.input.length + controls.length) return request;
+	const previousInput = request.input.slice(0, inputLength - controls.length);
+	let lastIndex = -1;
+	for (const control of controls) {
+		if (!isRecord(control) || typeof control.index !== "number" || !Number.isSafeInteger(control.index) || control.index <= lastIndex || control.index > previousInput.length || !isConfigurationUpdate(control.item)) return request;
+		previousInput.splice(control.index, 0, control.item);
+		lastIndex = control.index;
+	}
+	const previous = {
+		...request,
+		reasoning: {
+			...request.reasoning,
+			effort
+		},
+		input: previousInput
+	};
+	if (responsesContinuationRequestFingerprint(previous) !== requestHash) return request;
+	const prepared = replayResponsesReasoningUpdates(previous, request, outputLength);
+	if (responsesContinuationPrefixFingerprint((prepared.input ?? []).slice(0, inputLength + outputLength)) !== prefixHash) return request;
+	return prepared;
+}
+//#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 +1727,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 +1748,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 +1763,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 +1795,17 @@ 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,
+						restoreRequest: () => restoreResponsesReasoningState(context, model, responsesOptions, params)
+					});
+					if (continuationClaim) params = continuationClaim.fullRequest;
+				}
 				const observePrompt = createResponsesPromptEgressObserver(responsesOptions, context.systemPrompt);
 				const requestStartedAt = Date.now();
 				let started = false;
@@ -2659,7 +1840,7 @@ function createResponsesTransportExecutor(config) {
 						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint),
 						canRetryStream: () => output.content.length === 0,
 						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
-							if (continuationClaim) continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
+							continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
 							return withProviderResponseHook({
 								stream: observeResponsesStream(rawResponseStream, model, requestStartedAt),
 								signal: firstEvent.signal,
@@ -2675,6 +1856,7 @@ function createResponsesTransportExecutor(config) {
 					return responseStream;
 				};
 				let responseStream;
+				let websocketBaseline;
 				let finishWebSocket;
 				let transport = "sse";
 				const logWebSocketFallback = (reason) => emitModelTransportDebug(log, `[responses] websocket_fallback provider=${model.provider} api=${model.api} model=${model.id} reason=${reason}`);
@@ -2688,14 +1870,22 @@ function createResponsesTransportExecutor(config) {
 					const websocket = createOpenAIResponsesWebSocketStream({
 						client,
 						request: params,
+						restoreRequest: (request) => restoreResponsesReasoningState(context, model, responsesOptions, request),
 						mode: websocketMode,
 						sessionId: options?.sessionId,
 						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;
+					websocketBaseline = websocket.fullRequest;
+					recordResponsesInputReplay(output, websocket.inputReplay);
 					observePrompt?.(websocket.request, {
 						egress: "responses-websocket",
 						payloadVariant: "initial"
@@ -2737,7 +1927,8 @@ function createResponsesTransportExecutor(config) {
 							yield* await createSseStream();
 						}
 					} };
-				} catch {
+				} catch (error) {
+					if (error instanceof OpenAIResponsesWebSocketPostDispatchError) throw error;
 					closeWebSocketForFallback("setup_failure");
 					responseStream = await createSseStream();
 				}
@@ -2752,11 +1943,14 @@ function createResponsesTransportExecutor(config) {
 						reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
 							authProfileId: responsesOptions?.authProfileId,
 							sessionId: options?.sessionId
-						})
+						}),
+						asyncToolExecution: asyncTools
 					});
 					finishWebSocket?.();
 					if (options?.signal?.aborted) throw transportAbortError(options.signal);
 					if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+					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);
 				} catch (error) {
 					finishWebSocket?.({ keep: false });
@@ -3039,7 +2233,7 @@ const SIMPLE_TRANSPORT_API_ALIAS = {
 	"google-generative-ai": "openclaw-google-generative-ai-transport"
 };
 function createProviderOwnedGoogleTransportStreamFn(model, ctx) {
-	return getAiTransportHost().plugin.resolveProviderStream({
+	const streamFn = getAiTransportHost().plugin.resolveProviderStream({
 		provider: model.provider,
 		config: ctx?.cfg,
 		workspaceDir: ctx?.workspaceDir,
@@ -3066,6 +2260,10 @@ function createProviderOwnedGoogleTransportStreamFn(model, ctx) {
 			model
 		}
 	}) ?? void 0;
+	return streamFn ? (requestModel, context, options) => streamFn(requestModel, context, {
+		...options,
+		headers: resolveOpencodeSessionHeaders(requestModel, options)
+	}) : void 0;
 }
 function createSupportedTransportStreamFn(model, ctx) {
 	switch (model.api) {
@@ -3250,7 +2448,9 @@ function prepareProviderStreamModel(params) {
 	const streamFn = providerStreamFn ? wrapPluginProviderStream(providerStreamFn) : transportFallback && params.model.api === "google-generative-ai" ? wrapPluginProviderStream(transportFallback) : transportFallback;
 	if (!streamFn) return;
 	const api = params.apiRegistry.getApiProvider(params.model.api) ? resolveProviderStreamApi(params.model) : params.model.api;
-	if (!registerCustomApi(params.apiRegistry, api, streamFn)) return;
+	const sourceApi = params.model.api;
+	const sourceStreamFn = (runtimeModel, context, options) => streamFn(projectModel(runtimeModel, { api: sourceApi }), context, options);
+	if (!registerCustomApi(params.apiRegistry, api, sourceStreamFn)) return;
 	return api === params.model.api ? params.model : projectModel(params.model, { api });
 }
 function prepareModelForSimpleCompletion(params) {
@@ -3275,4 +2475,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, 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 };