@openclaw/ai 2026.9.1-beta.1 → 2026.9.2

package/dist/transports.mjs

@@ -1,31 +1,31 @@
-import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
-import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./src-Bu3FiFAG.mjs";
+import { _ as supportsClaudeAdaptiveThinking, b as supportsClaudeNativeXhighEffort, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-2qBGKg8O.mjs";
 import { c as normalizeLowercaseStringOrEmpty, o as isRecord, s as hasNonEmptyString } from "./utf16-slice-qz3nsy87.mjs";
-import { r as calculateCost } from "./sanitize-unicode-DCkltN94.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-D51fmkH6.mjs";
-import { i as canonicalizeBase64, o as stableStringify } from "./provider-error-DDOs_Bz0.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-Cd4hJG-S.mjs";
-import { r as asNonNegativeFiniteNumber } from "./number-coercion-H9qHik3g.mjs";
+import { r as calculateCost } from "./sanitize-unicode-D6xUvZaS.mjs";
+import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, h as defaultsClaudeAdaptiveThinking, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-CEvLw30U.mjs";
+import { i as stableStringify } from "./provider-error-9TraxGvt.mjs";
+import { r as toErrorObject } from "./diagnostics-DfFyKeX_.mjs";
+import { a as asNonNegativeFiniteNumber } from "./base64-CEFBpSkN.mjs";
 import { n as uniqueStrings } from "./string-normalization--fwJ4S2q.mjs";
+import { r as resolveOpenAIResponsesCacheParams } from "./openai-prompt-cache-CGnVB74a.mjs";
+import { A as createAnthropicInlineImageBudget, B as resolveAnthropicContextManagementBetaHeader, C as ANTHROPIC_SERVER_SIDE_FALLBACKS, D as readAnthropicFallbackBoundary, E as applyAnthropicFallbackBoundary, F as applyAnthropicEphemeralCacheControlMarkers, G as omitFoundryBearerCredentialHeaders, H as resolveAnthropicPayloadPolicy, I as applyAnthropicPayloadPolicyToParams, K as usesFoundryBearerAuth, L as isAnthropicServerToolClearingEnabled, M as resolveAnthropicImageMediaType, N as applyAnthropicCacheControlToMessages, O as resolveAnthropicFallbackServingModelCost, P as applyAnthropicContextManagementToRequest, R as isDirectAnthropicModel, S as readAnthropicInputTransformations, U as resolveAnthropicServerCompactionPlan, V as resolveAnthropicEphemeralCacheControl, W as isAnthropicOAuthApiKey, _ as toClaudeCodeToolName, a as suppressAnthropicCompaction, b as findActiveAnthropicToolTurnAssistantIndex, f as normalizeAnthropicToolCallId, g as resolveOriginalAnthropicToolName, h as reconcileAnthropicToolChoice, i as resolveNewestAnthropicCompaction, j as normalizeAnthropicInlineContent, k as applyAnthropicRefusal, m as projectAnthropicTools, n as createCompactionCapture, o as applyAnthropicMessageDeltaUsage, p as normalizeAnthropicToolChoice, r as isAnthropicReplayRejection, s as applyAnthropicMessageStartUsage, t as buildAnthropicReplayPlan, v as ANTHROPIC_OMITTED_REASONING_TEXT, w as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, x as logAnthropicThinkingDrops, y as applyAnthropicThinkingBindingControls, z as logAnthropicContextEdits } from "./anthropic-compaction-replay-DB2FGLQc.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary, t as adjustMaxTokensForThinking } from "./simple-options-CFj7x3J4.mjs";
-import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch } from "./tool-schema-json-projection-qvTEs5Am.mjs";
-import { a as isGoogleGemini3FlashModel, c as parseRetryAfterSeconds, f as resolveModelHeaderSentinels$1, h as supportsModelTools, i as isCodeModeModelVisibleToolName, l as readResponseTextSnippet, m as sha256Hex, n as createAbortError$1, o as isGoogleGemini3ProModel, p as resolveSecretSentinel, r as estimateStringChars, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as redactIdentifier } from "./transport-utils-LJ1_rbi-.mjs";
-import { A as resolveAnthropicImageMediaType, C as readAnthropicFallbackBoundary, D as usesFoundryBearerAuth, E as omitFoundryBearerCredentialHeaders, F as resolveAnthropicPayloadPolicy, I as resolveAnthropicServerCompactionPlan, M as applyAnthropicEphemeralCacheControlMarkers, N as applyAnthropicPayloadPolicyToParams, O as createAnthropicInlineImageBudget, P as resolveAnthropicEphemeralCacheControl, S as applyAnthropicFallbackBoundary, T as applyAnthropicRefusal, _ as ANTHROPIC_OMITTED_REASONING_TEXT, a as applyAnthropicMessageDeltaUsage, b as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, d as normalizeAnthropicToolCallId, f as normalizeAnthropicToolChoice, g as toClaudeCodeToolName, h as resolveOriginalAnthropicToolName, i as suppressAnthropicCompaction, j as applyAnthropicCacheControlToMessages, k as normalizeAnthropicInlineContent, m as reconcileAnthropicToolChoice, n as createCompactionCapture, o as applyAnthropicMessageStartUsage, p as projectAnthropicTools, r as isAnthropicReplayRejection, t as buildAnthropicReplayPlan, v as findActiveAnthropicToolTurnAssistantIndex, w as resolveAnthropicFallbackServingModelCost, y as ANTHROPIC_SERVER_SIDE_FALLBACKS } from "./anthropic-compaction-replay-nhKaCXu6.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-ljShVIZB.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-DUlGwRMz.mjs";
+import { a as codeModeToolSurfaceObserver, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking } from "./simple-options-BjHCCh4v.mjs";
+import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch } from "./tool-schema-json-projection-mJhXDcyz.mjs";
+import { a as isGoogleGemini3FlashModel, c as parseRetryAfterSeconds, f as resolveModelHeaderSentinels$1, i as isCodeModeModelVisibleToolName, l as readResponseTextSnippet, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as redactIdentifier } from "./transport-utils-7il795_9.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
+import { S as quoteUnsafeIntegerLiterals, _ as transportAbortError, a as createWritableTransportEventStream, b as parseJsonObjectPreservingUnsafeIntegers, c as finalizeTransportStream, d as notifyProviderHttpMetadata, f as notifyProviderHttpResponse, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, i as createEmptyTransportUsage, l as mergeTransportHeaders, m as parseTerminalToolCallArguments, n as coerceTransportToolCallArguments, o as failTransportStream, p as notifyProviderStreamOpened, r as copyProviderAcceptanceObserver, s as finalizeTerminalToolCallArguments, t as assignTransportErrorDetails, u as mergeTransportMetadata, v as withProviderAcceptanceObserver, x as parseJsonPreservingUnsafeIntegers, y as withProviderResponseHook } from "./transport-stream-shared-CZqMhfIw.mjs";
+import { C as createDeepSeekTextFilter, E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, T as tagPendingCommentaryText, _ as hasToolCallHistory, a as buildOpenAISdkClientOptions, b as resolveOpenAICompletionsCompat, c as filterCodeModePayloadTools, d as readCodeModePayloadToolName, f as resolveCodeModeResponsesVisibleToolNames, g as convertMessages, h as resolveOpenAIReasoningEffortMap, i as buildOpenAIClientHeaders, l as getCompat, m as usesNativeOpenAICodexResponsesBackend, n as shouldEmitOpenAICompletionsReasoning, o as buildOpenAISdkRequestOptions, p as resolveOpenAIStrictToolFlagWithDiagnostics, r as assertCodeModeResponsesToolSurface, s as enforceCodeModeResponsesToolSurface, t as processCompletionsStream, u as isOpenAICodexResponsesModel, v as finalizeOpenAICompletionsToolCalls, x as resolveOpenAICompletionsResponseFormat, y as detectOpenAICompletionsCompat } from "./openai-completions-stream-BsrBe3Gg.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
 import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as googleFlashSupportsMinimalThinking } from "./google-thinking-level-C-V3tecN.mjs";
-import { B as buildResponsesInputMessage, C as summarizeResponsesTools, G as suppressOpenAIResponsesCompaction, H as createOpenAIResponsesAssistantOutput, I as createResponsesStreamWithEncryptedContentRetry, J as resolveModelPayloadDebugMode, K as resolveReplayableResponsesMessageId, L as isInvalidEncryptedContentError, R as resolveAzureOpenAIApiVersion, S as summarizeResponsesPayload, U as buildOpenAIResponsesReasoningReplayMetadata, V as convertResponsesMessages, W as captureOpenAIResponsesCompaction, Y 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 emitModelTransportDebug, v as stringifyRedactedEvent, x as summarizeResponsesFailedNoDetailsObservation, y as stringifyRedactedPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DJThc6jW.mjs";
-import { t as codeModeToolSurfaceObserver } from "./provider-options-AvldWZt8.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-ho-hIkQf.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
-import { _ as isOpenAIGpt56Model, d as OpenAIResponsesWebSocketSafeRetryError, g as isOpenAIGpt55Model, h as isOpenAIGpt54MiniModel, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPostDispatchError, p as parseOpenAIResponsesWebSocketServerError, r as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError, v as normalizeOpenAIReasoningEffort, y as resolveOpenAIReasoningEffortForModel } from "./openai-responses-contracts-QUY12X0B.mjs";
-import { i as resolveOpenAIResponsesServerCompactionPlan, n as resolveOpenAIResponsesCompactEndpointPlan, r as resolveOpenAIResponsesPayloadPolicy, t as applyOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy-D8EdimYe.mjs";
+import { $ as resolveModelPayloadDebugMode, B as resolveNextResponsesEncryptedContentAttempt, C as summarizeResponsesPayload, G as responsesInputFingerprint, H as convertResponsesMessages, J as captureOpenAIResponsesCompaction, K as CompactionReplayRefreshRequiredError, L as createResponsesStreamWithEncryptedContentRetry, Q as emitModelTransportDebug, R as isInvalidEncryptedContentError, S as summarizeResponsesFailedNoDetailsObservation, U as createOpenAIResponsesAssistantOutput, V as buildResponsesInputMessage, W as recordResponsesInputReplay, X as suppressOpenAIResponsesCompaction, Y as resolveNewestOpenAIResponsesCompactionReplay, Z as resolveReplayableResponsesMessageId, _ as normalizeResponsesFailedEvent, b as stringifyRedactedPayload, et as resolveModelSseDebugMode, g as logResponsesFailedNoDetails, h as buildResponsesFailedNoDetailsObservation, l as processResponsesStream, m as ResponsesStreamFailure, n as applyResponsesServiceTierPricing, p as observeResponsesStream, q as buildOpenAIResponsesReasoningReplayMetadata, v as safeDebugValue, w as summarizeResponsesTools, x as summarizeOpenAITransportError, y as stringifyRedactedEvent, z as resolveAzureOpenAIApiVersion } from "./openai-responses-shared-Bmma_3Qc.mjs";
+import { A as readOpenAICompletionsReasoningBatch, C as createOpenAIProviderAcceptanceHook, D as measureUtf8AppendBytes, E as log, M as resolvePromptCacheKey, N as throwIfModelStreamAborted, O as parseOpenAICompletionsUsage, S as createModelStreamCooperativeScheduler, T as isOpenAICompletionsThinkingEnabled, b as reconcileOpenAIResponsesToolChoice, j as resolveOpenAIClientBaseUrl, k as readOpenAICompletionsContentDeltas, r as normalizeOpenAIStrictToolParameters, v as projectOpenAITools, w as createOpenAIResponseHook, x as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-_pTAJqKF.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
+import { C as isOpenAIGpt54MiniModel, E as normalizeOpenAIReasoningEffort, O as resolveOpenAIReasoningEffortForModel, T as isOpenAIGpt56Model, _ as OpenAIResponsesWebSocketPostDispatchError, a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, d as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, f as OPENAI_RESPONSES_APIS, i as sanitizeResponsesImagePayload, j as supportsOpenAITemperature, l as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch, v as OpenAIResponsesWebSocketPreDispatchError, w as isOpenAIGpt55Model, x as parseOpenAIResponsesWebSocketServerError, y as OpenAIResponsesWebSocketSafeRetryError } from "./openai-responses-compaction-window-BMVHFOtq.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
+import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-D0bhBfgL.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
 import { ResponsesWS } from "openai/resources/responses/ws.js";
@@ -35,12 +35,12 @@ import { ResponsesWS } from "openai/resources/responses/ws.js";
 * Converts OpenClaw contexts/tools into Anthropic payloads, streams SSE events
 * back into runtime output blocks, and applies provider request policy.
 */
-const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES = 8 * 1024;
+const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES = 8192;
 const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS = 400;
 const ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS = 1e4;
 const ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS = 4096;
 const ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR = 4;
-const ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS = 16 * 1024 * 1024;
+const ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS = 16777216;
 function resolveAnthropicRequestModelId(model) {
 	if (isDirectAnthropicModel(model) && /^anthropic\//i.test(model.id)) return model.id.replace(/^anthropic\//i, "");
 	return model.id;
@@ -60,14 +60,6 @@ function resolveAnthropicMessagesMaxTokens(params) {
 	const contextWindow = resolvePositiveAnthropicTokenLimit(params.modelContextWindow);
 	return contextWindow === void 0 ? ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS : Math.max(1, Math.min(ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS, Math.floor(contextWindow / ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR)));
 }
-function isAnthropicOAuthToken(apiKey) {
-	return (resolveSecretSentinel(apiKey) ?? apiKey).includes("sk-ant-oat");
-}
-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 ?? ""));
 }
@@ -137,14 +129,12 @@ async function convertAnthropicMessages(messages, model, isOAuthToken, options)
 		const msg = transformedMessages[i];
 		if (!msg) continue;
 		if (msg.role === "user") {
-			const isRuntimeContextCarrier = msg.runtimeContextCarrier === true;
 			if (typeof msg.content === "string") {
 				if (msg.content.trim().length > 0) {
 					const userParam = {
 						role: "user",
 						content: sanitizeTransportPayloadText(msg.content)
 					};
-					if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
 					params.push(userParam);
 				}
 				continue;
@@ -170,7 +160,6 @@ async function convertAnthropicMessages(messages, model, isOAuthToken, options)
 				role: "user",
 				content: filteredBlocks
 			};
-			if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
 			params.push(userParam);
 			continue;
 		}
@@ -406,12 +395,13 @@ async function* parseAnthropicSseBody(body, signal) {
 function createAnthropicMessagesClient(params) {
 	const url = resolveAnthropicMessagesUrl(params.baseURL);
 	return { messages: { async stream(body, options) {
-		const headers = mergeTransportHeaders({
+		const headers = new Headers(mergeTransportHeaders({
 			"content-type": "application/json",
 			"anthropic-version": "2023-06-01",
 			...params.apiKey ? { "x-api-key": params.apiKey } : {},
 			...params.authToken ? { authorization: `Bearer ${params.authToken}` } : {}
-		}, params.defaultHeaders);
+		}, params.defaultHeaders));
+		for (const [name, value] of Object.entries(options?.headers ?? {})) headers.set(name, value);
 		const response = await params.fetch(url, {
 			method: "POST",
 			headers,
@@ -482,7 +472,7 @@ function createAnthropicTransportClient(params) {
 	}
 	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
 	if (needsInterleavedBeta) betaFeatures.push("interleaved-thinking-2025-05-14");
-	if (isAnthropicOAuthToken(apiKey)) {
+	if (isAnthropicOAuthApiKey(apiKey)) {
 		const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: true });
 		return {
 			client: createAnthropicMessagesClient({
@@ -503,18 +493,20 @@ function createAnthropicTransportClient(params) {
 	}
 	if (useAnthropicServerSideFallback(model)) betaFeatures.push(ANTHROPIC_SERVER_SIDE_FALLBACK_BETA);
 	const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: false });
+	const defaultHeaders = mergeTransportHeaders({
+		accept: "application/json",
+		"anthropic-dangerous-direct-browser-access": "true",
+		...betaHeader ? { "anthropic-beta": betaHeader } : {}
+	}, model.headers, options?.headers);
 	return {
 		client: createAnthropicMessagesClient({
 			apiKey,
 			baseURL: model.baseUrl,
-			defaultHeaders: mergeTransportHeaders({
-				accept: "application/json",
-				"anthropic-dangerous-direct-browser-access": "true",
-				...betaHeader ? { "anthropic-beta": betaHeader } : {}
-			}, model.headers, options?.headers),
+			defaultHeaders,
 			fetch
 		}),
-		isOAuthToken: false
+		isOAuthToken: false,
+		directApiKeyBetaHeader: isDirectAnthropicModel(model) ? new Headers(defaultHeaders).get("anthropic-beta") ?? "" : void 0
 	};
 }
 async function buildAnthropicParams(model, context, isOAuthToken, options) {
@@ -533,7 +525,6 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		cacheRetention: options?.cacheRetention,
 		enableCacheControl: true
 	}, model);
-	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
 	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
 		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
 		authProfileId: options?.authProfileId,
@@ -541,7 +532,6 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 	});
 	const messages = await convertAnthropicMessages(replayPlan.messages, model, isOAuthToken, {
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
-		cacheBreakpointOptOutMessageIndexes,
 		compaction: replayPlan.compaction,
 		replayThinkingEnabled
 	});
@@ -579,18 +569,19 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		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"
+		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
 			};
-			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" };
+		} 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) {
@@ -598,7 +589,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		const projectedToolChoice = toolProjection ? reconcileAnthropicToolChoice(normalizedToolChoice, toolProjection) : normalizedToolChoice;
 		if (projectedToolChoice) params.tool_choice = projectedToolChoice;
 	}
-	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, cacheBreakpointOptOutMessageIndexes);
+	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, /* @__PURE__ */ new Set());
 	return {
 		params,
 		toolProjection,
@@ -633,7 +624,9 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 		toolChoice: options?.toolChoice,
 		thinkingBudgets: options?.thinkingBudgets,
 		reasoning,
-		...options?.anthropicServerCompaction === true ? { anthropicServerCompaction: true } : {},
+		anthropicServerCompaction: options?.anthropicServerCompaction,
+		anthropicCompactThreshold: options?.anthropicCompactThreshold,
+		cacheTtlPruning: options?.cacheTtlPruning,
 		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
 	});
 	if (reasoning === "off") {
@@ -674,17 +667,18 @@ function createAnthropicMessagesTransportStreamFn() {
 				stopReason: "stop",
 				timestamp: Date.now()
 			};
-			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream, () => notifyLlmRequestActivity(options?.signal)) : void 0;
+			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream) : void 0;
 			const eventSink = refusalBuffer ?? stream;
 			let costModel = model;
 			let messageStartPromptUsage;
 			let usedCompactionReplay = false;
+			let inputTransformations;
 			try {
 				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
 				if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 				const transportOptions = resolveAnthropicTransportOptions(model, options, apiKey);
 				const requestContext = prepareClaudeNoPrefillRequestContext(model, context);
-				const { client, isOAuthToken } = createAnthropicTransportClient({
+				const { client, isOAuthToken, directApiKeyBetaHeader } = createAnthropicTransportClient({
 					model,
 					context: requestContext,
 					apiKey,
@@ -694,13 +688,19 @@ function createAnthropicMessagesTransportStreamFn() {
 				usedCompactionReplay = builtParams.usedCompactionReplay;
 				let params = builtParams.params;
 				const toolProjection = builtParams.toolProjection;
+				applyAnthropicContextManagementToRequest(params, model, transportOptions, directApiKeyBetaHeader);
 				const nextParams = await transportOptions.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				applyClaudeRequestContract(params, model);
+				const betaHeader = resolveAnthropicContextManagementBetaHeader(params, directApiKeyBetaHeader);
+				const bindingHeaders = applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader !== void 0 ? { "anthropic-beta": betaHeader } : void 0);
 				const { response, stream: anthropicStream } = await client.messages.stream({
 					...params,
 					stream: true
-				}, transportOptions.signal ? { signal: transportOptions.signal } : void 0);
+				}, {
+					signal: transportOptions.signal,
+					headers: bindingHeaders
+				});
 				await notifyProviderHttpResponse({
 					options: transportOptions,
 					response,
@@ -815,6 +815,8 @@ function createAnthropicMessagesTransportStreamFn() {
 					});
 				};
 				for await (const event of anthropicStream) {
+					inputTransformations = readAnthropicInputTransformations(event) ?? inputTransformations;
+					notifyLlmRequestActivity(transportOptions.signal);
 					if (event.type === "error") {
 						const error = event.error;
 						throw new Error(error?.message || "Anthropic Messages stream failed");
@@ -987,16 +989,18 @@ function createAnthropicMessagesTransportStreamFn() {
 							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 (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;
 						}
@@ -1102,10 +1106,13 @@ function createAnthropicMessagesTransportStreamFn() {
 						continue;
 					}
 					if (event.type === "message_delta") {
+						logAnthropicContextEdits(event);
 						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);
+						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);
@@ -1134,20 +1141,22 @@ function createAnthropicMessagesTransportStreamFn() {
 					output
 				});
 			} catch (error) {
-				if (refusalBuffer) {
-					refusalBuffer.discard();
-					output.content = [];
-				} else output.content = output.content.filter((block) => block.type !== "toolCall");
-				if (usedCompactionReplay && isAnthropicReplayRejection(error)) suppressAnthropicCompaction(output, model, options);
 				failTransportStream({
 					stream,
 					output,
 					signal: options?.signal,
 					error,
 					cleanup: () => {
+						if (refusalBuffer) {
+							refusalBuffer.discard();
+							output.content = [];
+						} else output.content = output.content.filter((block) => block.type !== "toolCall");
+						if (usedCompactionReplay && isAnthropicReplayRejection(error)) suppressAnthropicCompaction(output, model, options);
 						for (const block of output.content) delete block.index;
 					}
 				});
+			} finally {
+				logAnthropicThinkingDrops(inputTransformations);
 			}
 		})();
 		return eventStream;
@@ -1595,10 +1604,11 @@ function convertTools(tools, compat, model) {
 function buildOpenAICompletionsParams(model, context, options) {
 	const compat = getCompat(model);
 	const compatDetection = detectOpenAICompletionsCompat(model);
-	let messages = convertMessages(model, context.systemPrompt ? {
+	const completionsContext = context.systemPrompt ? {
 		...context,
 		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
-	} : context, compat);
+	} : context;
+	let messages = convertMessages(model, completionsContext, compat);
 	applyCompletionsReplay(messages, context, model, compat);
 	if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
@@ -1659,8 +1669,10 @@ function buildOpenAICompletionsParams(model, context, options) {
 				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;
+		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({
@@ -1831,11 +1843,8 @@ function createOpenAICompletionsTransportStreamFn() {
 				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
 				const emitReasoning = shouldEmitOpenAICompletionsReasoning(model, options);
 				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-				const { data: responseStream, response } = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, firstEventAbort.signal, {
-					timeoutMs: options?.timeoutMs,
-					maxRetries: options?.maxRetries
-				})).withResponse();
-				await processCompletionsStream(withProviderResponseHook({
+				const { data: responseStream, response } = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, firstEventAbort.signal, { timeoutMs: options?.timeoutMs })).withResponse();
+				const hookedResponseStream = withProviderResponseHook({
 					stream: responseStream,
 					signal: firstEventAbort.signal,
 					abort: firstEventAbort.abort,
@@ -1844,9 +1853,11 @@ function createOpenAICompletionsTransportStreamFn() {
 						type: "start",
 						partial: output
 					})
-				}), output, model, stream, {
+				});
+				await processCompletionsStream(hookedResponseStream, output, model, stream, {
 					signal: options?.signal,
 					emitReasoning,
+					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
 					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 					abortFirstEventStream: firstEventAbort.abort,
 					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
@@ -1877,160 +1888,6 @@ function createOpenAICompletionsTransportStreamFn() {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-responses-compact-request.ts
-const COMPACT_REQUEST = Symbol("openaiResponsesCompactRequest");
-function claimResponsesCompactRequest(options) {
-	const controller = options ? Reflect.get(options, COMPACT_REQUEST) : void 0;
-	if (controller?.claimed === false) {
-		controller.claimed = true;
-		return controller;
-	}
-}
-/** Run a compact-endpoint request through the session's prepared stream stack. */
-async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context, options) {
-	const preparedOptions = { ...options };
-	let resolveResult;
-	let rejectResult;
-	const result = new Promise((resolve, reject) => {
-		resolveResult = resolve;
-		rejectResult = reject;
-	});
-	const controller = {
-		claimed: false,
-		resolve: resolveResult,
-		reject: rejectResult
-	};
-	Reflect.set(preparedOptions, COMPACT_REQUEST, controller);
-	const stream = await Promise.resolve(streamFn(model, context, preparedOptions));
-	if (!controller.claimed) throw new Error("Prepared stream did not reach an OpenAI Responses transport");
-	try {
-		return await result;
-	} finally {
-		await stream.result().catch(() => void 0);
-	}
-}
-//#endregion
-//#region packages/ai/src/transports/openai-responses-continuation.ts
-const HTTP_CONTINUATION_IDLE_TTL_MS = 300 * 1e3;
-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, ...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) {
-	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 (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))) 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",
@@ -2058,10 +1915,6 @@ function convertResponsesTools(tools, model, options) {
 		})
 	};
 }
-function getPromptCacheRetention(baseUrl, cacheRetention) {
-	if (cacheRetention !== "long") return;
-	return baseUrl?.includes("api.openai.com") ? "24h" : void 0;
-}
 function resolveOpenAIReasoningEffort(options) {
 	return normalizeOpenAIReasoningEffort(options?.reasoningEffort ?? options?.reasoning ?? "high");
 }
@@ -2112,18 +1965,28 @@ function sanitizeOpenAICodexResponsesParams(model, params) {
 	stripOpenAICodexResponsesUnsupportedTextFields(params);
 	return params;
 }
-function buildOpenAICodexResponsesInstructions(context) {
+function buildOpenAIResponsesInstructionsText(context) {
 	if (!context.systemPrompt) return;
 	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
 }
-function resolveOpenAICodexResponsesInstructions(model, context) {
-	const instructions = buildOpenAICodexResponsesInstructions(context);
+function resolveOpenAIResponsesInstructions(model, context, usesInstructionsField) {
+	if (!usesInstructionsField) return;
+	const instructions = buildOpenAIResponsesInstructionsText(context);
 	if (instructions && instructions.trim().length > 0) return instructions;
 	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
 }
-function ensureOpenAICodexResponsesInput(messages, context) {
+function buildOpenAIResponsesCompactSystemMessage(model, instructions) {
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	const role = model.reasoning && supportsDeveloperRole !== false ? "developer" : "system";
+	return buildResponsesInputMessage(role, [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(messages, context) {
 	if (messages.length > 0 || !context.systemPrompt) return;
-	if (!buildOpenAICodexResponsesInstructions(context)) throw new Error("OpenAI Codex Responses requires non-empty input when only systemPrompt is provided.");
+	if (!buildOpenAIResponsesInstructionsText(context)) throw new Error("OpenAI Responses requires non-empty input when only systemPrompt is provided.");
 	messages.push(buildResponsesInputMessage("user", [{
 		type: "input_text",
 		text: " "
@@ -2137,16 +2000,12 @@ function resolveOpenAIResponsesTextFormat(responseFormat) {
 	return responseFormat;
 }
 function convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode) {
-	const isCodexResponses = isOpenAICodexResponsesModel(model);
 	const isNativeCodexResponses = usesNativeOpenAICodexResponsesBackend(model);
-	const compat = getCompat(model);
-	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
 	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: !isCodexResponses,
-		supportsDeveloperRole,
+		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
 		replayReasoningItems: true,
 		replayResponsesItemIds,
 		authProfileId: options?.authProfileId,
@@ -2155,25 +2014,25 @@ function convertOpenAIResponsesMessagesForRequest(model, context, options, repla
 	});
 }
 function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
-	const isCodexResponses = isOpenAICodexResponsesModel(model);
 	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
 	const messages = convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode);
-	if (isCodexResponses) ensureOpenAICodexResponsesInput(messages, context);
+	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),
-		...isCodexResponses ? { instructions: resolveOpenAICodexResponsesInstructions(model, context) } : {},
+		...resolveOpenAIResponsesCacheParams(model, cacheRetention, model.baseUrl?.includes("api.openai.com")),
+		...instructions ? { instructions } : {},
 		...metadata ? { metadata } : {}
 	};
 	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
-	if (effectiveMaxTokens) params.max_output_tokens = effectiveMaxTokens;
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (options?.topP !== void 0) params.top_p = options.topP;
+	if (effectiveMaxTokens) params.max_output_tokens = Math.max(effectiveMaxTokens, 16);
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
+	if (options?.topP !== void 0 && model.id !== "gpt-6-astra") params.top_p = options.topP;
 	if (options?.responseFormat !== void 0) params.text = {
 		...params.text,
 		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
@@ -2189,9 +2048,10 @@ function buildOpenAIResponsesParams(model, context, options, metadata, replayMod
 	}
 	if (model.reasoning) {
 		if (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) {
+			const requestedReasoningEffort = resolveOpenAIReasoningEffort(options);
 			const resolvedReasoningEffort = resolveOpenAIReasoningEffortForModel({
 				model,
-				effort: resolveOpenAIReasoningEffort(options)
+				effort: requestedReasoningEffort
 			});
 			const reasoningEffort = resolvedReasoningEffort ? raiseMinimalReasoningForResponsesWebSearch({
 				model,
@@ -2217,9 +2077,311 @@ function buildOpenAIResponsesParams(model, context, options, metadata, replayMod
 	return sanitizeOpenAICodexResponsesParams(model, params);
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-reasoning-update.ts
+function isConfigurationUpdate(value) {
+	return isRecord(value) && value.type === "configuration_update" && isRecord(value.reasoning) && typeof value.reasoning.effort === "string";
+}
+function isResponsesReasoningUpdateCompatible(request) {
+	const mode = isRecord(request.reasoning) ? request.reasoning.mode : void 0;
+	return request.model === "gpt-6-astra" && (mode === void 0 || mode === "standard") && (!isRecord(request.multi_agent) || request.multi_agent.enabled !== true) && request.truncation !== "auto" && (!Array.isArray(request.context_management) || !request.context_management.some((item) => isRecord(item) && item.type === "compaction"));
+}
+function supportsResponsesReasoningUpdate(request) {
+	return isResponsesReasoningUpdateCompatible(request) && isRecord(request.reasoning) && typeof request.reasoning.effort === "string";
+}
+function canReferenceResponsesReasoningHistory(previous, request) {
+	return !previous.input?.some(isConfigurationUpdate) || isResponsesReasoningUpdateCompatible(request);
+}
+/** Rehydrate input controls only provisionally; continuation must validate the full prefix. */
+function replayResponsesReasoningUpdates(previous, request, previousOutputLength, steering) {
+	if (steering !== "required-input" && (!supportsResponsesReasoningUpdate(previous) || !supportsResponsesReasoningUpdate(request)) || !Array.isArray(previous.input) || !Array.isArray(request.input) || request.input.some(isConfigurationUpdate)) return request;
+	const input = [...request.input];
+	let activeEffort = isRecord(previous.reasoning) ? previous.reasoning.effort : void 0;
+	for (const [index, item] of previous.input.entries()) if (isConfigurationUpdate(item)) {
+		input.splice(index, 0, item);
+		activeEffort = item.reasoning.effort;
+	}
+	if (steering === "required-input") return input.length === request.input.length ? request : {
+		...request,
+		input
+	};
+	if (!isRecord(previous.reasoning) || !isRecord(request.reasoning) || typeof request.reasoning.effort !== "string") return request;
+	if (activeEffort !== request.reasoning.effort && steering !== "automatic") {
+		const baselineLength = previous.input.length + previousOutputLength;
+		const nextUser = input.findIndex((item, index) => index >= baselineLength && "role" in item && item.role === "user");
+		if (nextUser === -1) return request;
+		input.splice(nextUser, 0, {
+			type: "configuration_update",
+			reasoning: { effort: request.reasoning.effort }
+		});
+	}
+	if (input.length === request.input.length && activeEffort === request.reasoning.effort) return request;
+	return {
+		...request,
+		reasoning: {
+			...request.reasoning,
+			effort: previous.reasoning.effort
+		},
+		input
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-continuation.ts
+const HTTP_CONTINUATION_IDLE_TTL_MS = 3e5;
+const TURN_HEADERS = /* @__PURE__ */ new Set([
+	"traceparent",
+	"x-openclaw-turn-id",
+	"x-openclaw-turn-attempt"
+]);
+function jsonValuesEqual(left, right) {
+	const leftJson = JSON.stringify(left);
+	const normalizedLeft = stableStringify(JSON.parse(leftJson));
+	const rightJson = JSON.stringify(right);
+	return leftJson === rightJson || normalizedLeft === stableStringify(JSON.parse(rightJson));
+}
+function requestWithoutInput(request) {
+	const { input: _input, previous_response_id: _previousResponseId, instructions: _instructions, tools: _tools, ...rest } = request;
+	if (!isRecord(rest.metadata)) return rest;
+	const metadata = Object.fromEntries(Object.entries(rest.metadata).filter(([key]) => key !== "openclaw_turn_id" && key !== "openclaw_turn_attempt"));
+	return {
+		...rest,
+		metadata
+	};
+}
+function normalizeAssistantReplayInput(input, fromResponse = false) {
+	return input.map((item) => {
+		if (!isRecord(item)) return item;
+		if (item.type === "reasoning") return { type: "reasoning" };
+		if (item.type !== "function_call" && !(item.type === "message" && item.role === "assistant")) return item;
+		const { id: _id, status: _status, ...stableItem } = item;
+		if (fromResponse && item.type === "function_call") {
+			const args = parseJsonObjectPreservingUnsafeIntegers(stableItem.arguments);
+			stableItem.arguments = args ? JSON.stringify(args) : stableItem.arguments;
+		}
+		if (item.type === "message" && Array.isArray(stableItem.content)) stableItem.content = stableItem.content.map((part) => {
+			if (!isRecord(part) || part.type !== "output_text") return part;
+			const { annotations: _annotations, logprobs: _logprobs, ...stablePart } = part;
+			return stablePart;
+		});
+		return stableItem;
+	});
+}
+function resolveResponsesContinuationRequest(continuation, request, steering) {
+	if (!continuation) return {
+		request,
+		continuationStatus: "no_previous_response"
+	};
+	if (request.previous_response_id) return {
+		request,
+		continuationStatus: "explicit_previous_response_id"
+	};
+	if (!canReferenceResponsesReasoningHistory(continuation.lastRequest, request)) return {
+		request,
+		continuationStatus: "request_changed"
+	};
+	const prepared = replayResponsesReasoningUpdates(continuation.lastRequest, request, continuation.lastResponseItems.length, steering);
+	if (steering !== "required-input" && !jsonValuesEqual(requestWithoutInput(prepared), requestWithoutInput(continuation.lastRequest))) return {
+		request,
+		continuationStatus: "request_changed"
+	};
+	const currentInput = prepared.input ?? [];
+	const previousInput = continuation.lastRequest.input ?? [];
+	const baselineLength = previousInput.length + continuation.lastResponseItems.length;
+	if (currentInput.length < baselineLength) return {
+		request,
+		continuationStatus: "history_shorter"
+	};
+	if (!jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(0, previousInput.length)), normalizeAssistantReplayInput(previousInput)) || !jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(previousInput.length, baselineLength)), normalizeAssistantReplayInput(continuation.lastResponseItems, true))) return {
+		request,
+		continuationStatus: "history_changed"
+	};
+	return {
+		request: {
+			...prepared,
+			previous_response_id: continuation.lastResponseId,
+			input: currentInput.slice(baselineLength)
+		},
+		...prepared !== request ? { fullRequest: prepared } : {},
+		continuationStatus: "continued"
+	};
+}
+const httpContinuationEntries = /* @__PURE__ */ new Map();
+function deleteHttpContinuationIfOwned(key, entry) {
+	if (httpContinuationEntries.get(key) === entry) httpContinuationEntries.delete(key);
+}
+function connectionIdentity(params) {
+	const headers = Object.entries(resolveAiTransportHeaderSentinels(params.headers) ?? {}).map(([name, value]) => [name.toLowerCase(), value]).filter(([name]) => !TURN_HEADERS.has(name)).toSorted(([a], [b]) => a.localeCompare(b));
+	return sha256Hex(JSON.stringify([
+		getAiTransportHost().resolveSecretSentinel(params.apiKey),
+		params.baseUrl,
+		headers
+	]));
+}
+function claimOpenAIResponsesHttpContinuation(params) {
+	const key = `${params.sessionId}\0${connectionIdentity(params)}`;
+	const previous = httpContinuationEntries.get(key);
+	if (previous?.kind === "claimed") return;
+	if (previous?.kind === "ready") clearTimeout(previous.idleTimer);
+	const claimed = {
+		kind: "claimed",
+		sessionId: params.sessionId
+	};
+	httpContinuationEntries.set(key, claimed);
+	try {
+		const resolved = resolveResponsesContinuationRequest(previous?.kind === "ready" ? previous.state : void 0, params.request);
+		const fullRequest = resolved.fullRequest ?? params.request;
+		return {
+			request: params.request.store === false ? fullRequest : resolved.request,
+			fullRequest,
+			commit: (effectiveRequest, response) => {
+				if (httpContinuationEntries.get(key) !== claimed) return;
+				const ready = {
+					...claimed,
+					kind: "ready",
+					state: {
+						lastRequest: effectiveRequest,
+						lastResponseId: response.id,
+						lastResponseItems: response.output
+					},
+					idleTimer: setTimeout(() => deleteHttpContinuationIfOwned(key, ready), HTTP_CONTINUATION_IDLE_TTL_MS)
+				};
+				ready.idleTimer.unref?.();
+				httpContinuationEntries.set(key, ready);
+			},
+			release: () => deleteHttpContinuationIfOwned(key, claimed)
+		};
+	} catch (error) {
+		deleteHttpContinuationIfOwned(key, claimed);
+		throw error;
+	}
+}
+registerSessionResourceCleanup((sessionId) => {
+	for (const [key, entry] of httpContinuationEntries) if (!sessionId || entry.sessionId === sessionId) {
+		if (entry.kind === "ready") clearTimeout(entry.idleTimer);
+		httpContinuationEntries.delete(key);
+	}
+});
+//#endregion
+//#region packages/ai/src/transports/openai-responses-steering.ts
+function cloneWireRequest(request) {
+	const serialized = JSON.stringify(request);
+	return JSON.parse(serialized);
+}
+async function projectResponsesSteeringInput(request, project) {
+	const { input: activeInput, ...activeSettings } = cloneWireRequest(request);
+	if (!Array.isArray(activeInput)) return [];
+	const { input, ...settings } = cloneWireRequest(await project());
+	if (!Array.isArray(input) || stableStringify(settings) !== stableStringify(activeSettings) || stableStringify(input.slice(0, activeInput.length)) !== stableStringify(activeInput)) return [];
+	const projected = input.slice(activeInput.length);
+	return projected.every((item) => isRecord(item) && item.role === "user") ? projected : [];
+}
+/** One response owns admission; accepted input stays on this connection until continuation. */
+function createResponsesSteering(params) {
+	let responseId;
+	let sealed = false;
+	let unsubscribe;
+	const pending = [];
+	const accepted = /* @__PURE__ */ new Map();
+	const acknowledged = /* @__PURE__ */ new Set();
+	const seal = () => {
+		sealed = true;
+		const cleanup = unsubscribe;
+		unsubscribe = void 0;
+		cleanup?.();
+	};
+	return {
+		get responseId() {
+			return responseId;
+		},
+		get pending() {
+			return pending.length > 0;
+		},
+		get acceptedInput() {
+			return [...accepted.values()].flat();
+		},
+		seal,
+		close(error) {
+			seal();
+			for (const submission of pending.splice(0)) submission.reject(error);
+		},
+		handle(event) {
+			if (!isRecord(event)) return false;
+			if (event.type === "response.created" && !responseId && !sealed) {
+				const response = isRecord(event.response) ? event.response : void 0;
+				if (typeof response?.id !== "string" || !response.id.trim()) throw new Error("Responses steering requires a response identity");
+				const activeResponseId = response.id;
+				responseId = activeResponseId;
+				const cleanup = params.onActiveResponse({
+					needsContinuation: params.needsContinuation,
+					steer(messages) {
+						if (sealed || messages.length === 0) return Promise.resolve(false);
+						params.assertActive();
+						const converted = params.toInput(messages);
+						const submit = (input) => {
+							if (sealed || input.length === 0) return Promise.resolve(false);
+							params.assertActive();
+							return new Promise((resolve, reject) => {
+								pending.push({
+									input,
+									resolve,
+									reject
+								});
+								params.send({
+									type: "response.steer",
+									previous_response_id: activeResponseId,
+									input
+								});
+							});
+						};
+						return Array.isArray(converted) ? submit(converted) : converted.then(submit);
+					}
+				});
+				if (sealed) cleanup?.();
+				else unsubscribe = cleanup;
+				return false;
+			}
+			if (event.type !== "response.steer.accepted" && event.type !== "response.steer.failed" && event.type !== "response.steer.pending") return false;
+			const steer = isRecord(event.steer) ? event.steer : void 0;
+			if (!responseId || steer?.previous_response_id !== responseId) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.failed" && steer.id === void 0) {
+				const index = pending.findIndex((submission) => stableStringify(submission.input) === stableStringify(steer.input));
+				const submission = pending[index];
+				if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+				pending.splice(index, 1);
+				submission.resolve(false);
+				return true;
+			}
+			if (typeof steer.id !== "string" || !steer.id.trim()) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.pending") {
+				if (!accepted.has(steer.id)) throw new Error("Responses steering pending event has no accepted submission");
+				return true;
+			}
+			if (event.type === "response.steer.failed" && accepted.has(steer.id)) throw new Error("OpenAI could not apply accepted steering; the queued message remains in the conversation");
+			if (acknowledged.has(steer.id)) throw new Error("Responses steering acknowledgement was already applied");
+			const submission = pending.shift();
+			if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+			acknowledged.add(steer.id);
+			if (event.type === "response.steer.accepted") {
+				accepted.set(steer.id, submission.input);
+				submission.resolve(true);
+			} else submission.resolve(false);
+			return true;
+		}
+	};
+}
+/** Accepted steering is prepended by the server, so never repeat it in response.create. */
+function omitAcceptedSteering(input, accepted) {
+	const remaining = [...input];
+	for (const message of accepted) {
+		const index = remaining.findIndex((item) => stableStringify(item) === stableStringify(message));
+		if (index < 0) throw new Error("Responses steering continuation no longer contains the accepted user input");
+		remaining.splice(index, 1);
+	}
+	return remaining;
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-websocket.ts
-const SESSION_WEBSOCKET_CACHE_TTL_MS = 300 * 1e3;
-const SESSION_WEBSOCKET_MAX_AGE_MS = 3300 * 1e3;
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
 const WEBSOCKET_OPEN_STATE = 1;
 const websocketSessionCache = /* @__PURE__ */ new Map();
 const degradedWebSocketConnections = /* @__PURE__ */ new Map();
@@ -2249,6 +2411,9 @@ function invalidateOwnedWebSocketSession(cacheKey, entry, reason = "done") {
 		entry.idleTimer = void 0;
 	}
 	closeWebSocketSilently(entry.socket, reason);
+	entry.steeringContinuation?.steering.close(/* @__PURE__ */ new Error("Responses steering connection closed"));
+	entry.steeringContinuation?.iterator.return?.().catch(() => void 0);
+	entry.steeringContinuation = void 0;
 	if (websocketSessionCache.get(cacheKey) === entry) websocketSessionCache.delete(cacheKey);
 }
 function scheduleSessionWebSocketExpiry(cacheKey, entry) {
@@ -2298,11 +2463,14 @@ function createTransientWebSocketLease(connection) {
 }
 function createCachedWebSocketLease(cacheKey, entry, reusedConnection) {
 	entry.busy = true;
+	const steeringContinuation = entry.steeringContinuation;
+	entry.steeringContinuation = void 0;
 	return {
 		socket: entry.socket,
-		iterator: entry.socket.stream(),
+		iterator: steeringContinuation?.iterator ?? entry.socket.stream(),
 		entry,
 		reusedConnection,
+		steeringContinuation,
 		release: ({ keep } = {}) => {
 			if (!keep || entry.socket.socket.readyState !== WEBSOCKET_OPEN_STATE) {
 				invalidateOwnedWebSocketSession(cacheKey, entry);
@@ -2386,11 +2554,13 @@ function createOpenAIResponsesWebSocketStream(params) {
 		throw new OpenAIResponsesWebSocketPreDispatchError(error);
 	}
 	let prepared;
+	const resumedSteering = lease.steeringContinuation;
+	const steeringMode = resumedSteering ? resumedSteering.requiresInput ? "required-input" : "automatic" : void 0;
 	try {
 		const continuation = lease.entry?.continuation;
 		if (continuation && lease.entry) {
 			lease.entry.continuation = void 0;
-			prepared = resolveResponsesContinuationRequest(continuation, fullRequest);
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
 		} else prepared = {
 			request: fullRequest,
 			continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
@@ -2404,11 +2574,54 @@ function createOpenAIResponsesWebSocketStream(params) {
 	let terminalResponse;
 	let terminalReceived = false;
 	let released = false;
+	let retainIterator = false;
+	let deferredInput = false;
+	let inputReplay;
+	if (resumedSteering) try {
+		if (prepared.continuationStatus !== "continued" || !prepared.request.previous_response_id) throw new Error("Responses steering continuation changed its request or history");
+		const input = omitAcceptedSteering(prepared.request.input ?? [], resumedSteering.acceptedInput);
+		if (!resumedSteering.requiresInput && (stableStringify(fullRequest.instructions) !== stableStringify(resumedSteering.instructions) || stableStringify(fullRequest.tools) !== stableStringify(resumedSteering.tools))) throw new Error("Responses automatic steering continuation cannot change instructions or tools");
+		const baseline = prepared.fullRequest ?? fullRequest;
+		const priorLength = (baseline.input?.length ?? 0) - (prepared.request.input?.length ?? 0);
+		const fingerprints = input.map(responsesInputFingerprint);
+		if (fingerprints.length > 0) inputReplay = {
+			afterResponseId: prepared.request.previous_response_id,
+			before: resumedSteering.requiresInput ? fingerprints : [],
+			after: resumedSteering.requiresInput ? [] : fingerprints
+		};
+		const delivered = resumedSteering.requiresInput ? input : [];
+		prepared.fullRequest = {
+			...baseline,
+			input: [
+				...(baseline.input ?? []).slice(0, priorLength),
+				...resumedSteering.acceptedInput,
+				...delivered
+			]
+		};
+		prepared.request = {
+			...prepared.request,
+			input: delivered
+		};
+		deferredInput = !resumedSteering.requiresInput && input.length > 0;
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw new OpenAIResponsesWebSocketPostDispatchError(error);
+	}
+	const steering = lease.entry && params.onActiveResponse && params.steeringInput ? createResponsesSteering({
+		onActiveResponse: params.onActiveResponse,
+		toInput: params.steeringInput,
+		send: (event) => lease.socket.sendRaw(JSON.stringify(event)),
+		needsContinuation: () => deferredInput,
+		assertActive: () => {
+			if (released || terminalReceived || params.signal?.aborted) throw new Error("Responses steering is no longer active");
+		}
+	}) : void 0;
 	const finish = ({ keep = true } = {}) => {
 		if (released) return;
 		released = true;
 		if (keep && lease.entry && terminalResponse) lease.entry.continuation = {
-			lastRequest: fullRequest,
+			lastRequest: prepared.fullRequest ?? fullRequest,
 			lastResponseId: terminalResponse.id,
 			lastResponseItems: terminalResponse.output
 		};
@@ -2422,8 +2635,19 @@ function createOpenAIResponsesWebSocketStream(params) {
 			let requestDispatched = false;
 			try {
 				if (params.signal?.aborted) throw transportAbortError(params.signal);
+				if (resumedSteering) {
+					requestDispatched = true;
+					if (resumedSteering.requiresInput) lease.socket.send({
+						...prepared.request,
+						type: "response.create"
+					});
+				}
 				for (;;) {
-					const next = await nextWebSocketMessage(iterator, params.signal);
+					const buffered = resumedSteering?.buffered.shift();
+					const next = buffered ? {
+						value: buffered,
+						done: false
+					} : await nextWebSocketMessage(iterator, params.signal);
 					if (next.done) throw new Error("OpenAI Responses WebSocket closed before a terminal response event");
 					if (next.value.type === "open") {
 						if (!requestDispatched) {
@@ -2437,8 +2661,51 @@ function createOpenAIResponsesWebSocketStream(params) {
 					}
 					const event = readServerEvent(next.value);
 					if (!event) continue;
+					if (isRecord(event) && typeof event.type === "string" && event.type.startsWith("response.steer.")) {
+						if ((isRecord(event.steer) && event.steer.previous_response_id === steering?.responseId ? steering : resumedSteering?.steering ?? steering)?.handle(event)) continue;
+					}
+					steering?.handle(event);
 					if (event.type === "response.completed") terminalResponse = event.response;
 					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
+					if (terminalReceived) {
+						steering?.seal();
+						if (event.type === "response.failed") steering?.close(/* @__PURE__ */ new Error("Responses failed before steering could be applied"));
+						const continuationBuffer = [];
+						for (;;) {
+							if (!steering?.pending) break;
+							const acknowledgement = await nextWebSocketMessage(iterator, params.signal);
+							if (acknowledgement.done) throw new Error("Responses closed before acknowledging steering");
+							const acknowledgedEvent = readServerEvent(acknowledgement.value);
+							if (!steering.handle(acknowledgedEvent)) continuationBuffer.push(acknowledgement.value);
+						}
+						const acceptedInput = steering?.acceptedInput ?? [];
+						const isSteered = event.type === "response.incomplete" && isRecord(event.response.incomplete_details) && event.response.incomplete_details.reason === "steered";
+						if (lease.entry && steering && acceptedInput.length > 0 && (event.type === "response.completed" || isSteered)) {
+							if (event.type === "response.incomplete") terminalResponse = event.response;
+							lease.entry.steeringContinuation = {
+								iterator,
+								buffered: continuationBuffer,
+								acceptedInput,
+								requiresInput: (terminalResponse?.output ?? []).some((item) => (item.type === "function_call" || item.type === "custom_tool_call") && !(isRecord(item) && item.async === true) || item.type === "mcp_approval_request"),
+								steering,
+								instructions: fullRequest.instructions,
+								tools: fullRequest.tools
+							};
+							retainIterator = true;
+							if (isSteered) {
+								yield {
+									...event,
+									type: "response.completed",
+									response: {
+										...event.response,
+										status: "completed",
+										incomplete_details: null
+									}
+								};
+								return;
+							}
+						}
+					}
 					yield event;
 					if (terminalReceived) {
 						degradedWebSocketConnections.delete(degradationKey);
@@ -2446,20 +2713,27 @@ function createOpenAIResponsesWebSocketStream(params) {
 					}
 				}
 			} catch (error) {
+				const steeringDispatched = Boolean(steering?.pending || steering?.acceptedInput.length || resumedSteering);
+				steering?.close(error instanceof Error ? error : /* @__PURE__ */ new Error("Responses steering failed"));
 				if (lease.entry) lease.entry.continuation = void 0;
-				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError;
+				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError && !steeringDispatched;
 				if (!params.callerSignal?.aborted && !safeRetry) markDegraded();
 				if (!requestDispatched && !params.signal?.aborted) throw new OpenAIResponsesWebSocketPreDispatchError(error);
 				if (!requestDispatched || params.callerSignal?.aborted || safeRetry) throw error;
 				throw new OpenAIResponsesWebSocketPostDispatchError(error);
 			} finally {
-				await iterator.return?.().catch(() => void 0);
+				steering?.seal();
+				if (!retainIterator) {
+					steering?.close(/* @__PURE__ */ new Error("Responses stream ended before steering was confirmed"));
+					await iterator.return?.().catch(() => void 0);
+				}
 				if (!terminalReceived) finish({ keep: false });
 			}
 		} },
 		request: prepared.request,
 		reusedConnection: lease.reusedConnection,
 		continuationStatus: prepared.continuationStatus,
+		inputReplay,
 		finish
 	};
 }
@@ -2472,147 +2746,68 @@ function closeOpenAIResponsesWebSocketSessions(sessionId) {
 }
 registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
 //#endregion
-//#region packages/media-core/src/inline-image-data-url.ts
-/** Prefix used to distinguish inline data URLs from remote/local image references. */
-const INLINE_IMAGE_DATA_URL_PREFIX = "data:";
-const IMAGE_SIGNATURES = [
-	{
-		mime: "image/png",
-		matches: (buffer) => buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10
-	},
-	{
-		mime: "image/jpeg",
-		matches: (buffer) => buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255
-	},
-	{
-		mime: "image/webp",
-		matches: (buffer) => buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP"
-	},
-	{
-		mime: "image/gif",
-		matches: (buffer) => buffer.length >= 6 && (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a")
-	},
-	{
-		mime: "image/bmp",
-		matches: (buffer) => buffer.length >= 2 && buffer[0] === 66 && buffer[1] === 77
-	}
-];
-const HEIC_BRANDS = /* @__PURE__ */ new Set([
-	"heic",
-	"heix",
-	"hevc",
-	"hevx",
-	"heis",
-	"heim",
-	"hevm",
-	"hevs"
-]);
-const HEIF_BRANDS = /* @__PURE__ */ new Set(["mif1", "msf1"]);
-const IMAGE_SIGNATURE_PREFIX_BASE64_CHARS = 128;
-const INLINE_IMAGE_DATA_URL_MIMES = /* @__PURE__ */ new Set([
-	"image/png",
-	"image/jpeg",
-	"image/webp",
-	"image/gif"
-]);
-function startsWithDataUrl(value) {
-	return value.slice(0, 5).toLowerCase() === INLINE_IMAGE_DATA_URL_PREFIX;
-}
-function sniffIsoBmffImageMime(buffer) {
-	if (buffer.length < 12 || buffer.subarray(4, 8).toString("ascii") !== "ftyp") return;
-	const brands = [buffer.subarray(8, 12).toString("ascii")];
-	for (let offset = 16; offset + 4 <= buffer.length; offset += 4) brands.push(buffer.subarray(offset, offset + 4).toString("ascii"));
-	if (brands.some((brand) => HEIC_BRANDS.has(brand))) return "image/heic";
-	if (brands.some((brand) => HEIF_BRANDS.has(brand))) return "image/heif";
-}
-/** Sniffs supported inline image formats from decoded bytes. */
-function sniffInlineImageMime(buffer) {
-	return IMAGE_SIGNATURES.find((signature) => signature.matches(buffer))?.mime ?? sniffIsoBmffImageMime(buffer);
-}
-function isImageMimeType(value) {
-	return value.trim().toLowerCase().startsWith("image/");
-}
-/** Canonicalizes trusted inline image base64 and rejects malformed or non-image payloads. */
-function sanitizeInlineImageBase64(params) {
-	if (!isImageMimeType(params.mimeType)) return;
-	const canonicalPayload = canonicalizeBase64(params.base64);
-	if (!canonicalPayload) return;
-	const sniffedMimeType = sniffInlineImageMime(Buffer.from(canonicalPayload.slice(0, IMAGE_SIGNATURE_PREFIX_BASE64_CHARS), "base64"));
-	if (!sniffedMimeType) return;
-	return {
-		mimeType: sniffedMimeType,
-		base64: canonicalPayload
-	};
-}
-function parseInlineImageDataUrl(value) {
-	if (!startsWithDataUrl(value)) return {
-		metadata: [],
-		payload: value
-	};
-	const commaIndex = value.indexOf(",");
-	if (commaIndex < 0) return;
-	return {
-		metadata: value.slice(5, commaIndex).split(";").map((part) => part.trim()),
-		payload: value.slice(commaIndex + 1)
-	};
-}
-function metadataAllowsImageBase64(metadata) {
-	const [mimeType, ...options] = metadata;
-	return mimeType !== void 0 && isImageMimeType(mimeType) && options.some((part) => part.toLowerCase() === "base64");
-}
-function sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, allowedMimes) {
-	const parsed = parseInlineImageDataUrl(imageUrl);
-	if (!parsed) return;
-	if (parsed.metadata.length === 0) return imageUrl;
-	if (!metadataAllowsImageBase64(parsed.metadata)) return;
-	const [mimeType] = parsed.metadata;
-	const sanitized = sanitizeInlineImageBase64({
-		mimeType: mimeType ?? "",
-		base64: parsed.payload
+//#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
+		}
 	});
-	if (!sanitized) return;
-	if (allowedMimes && !allowedMimes.has(sanitized.mimeType)) return;
-	return `data:${sanitized.mimeType};base64,${sanitized.base64}`;
-}
-/** Canonicalizes provider-safe inline image data URLs and rejects unsupported formats. */
-function sanitizeInlineImageDataUrl(imageUrl) {
-	return sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, INLINE_IMAGE_DATA_URL_MIMES);
-}
-//#endregion
-//#region packages/ai/src/transports/responses-image-payload-sanitizer.ts
-/**
-* Sanitizes OpenAI Responses payloads before transport. Invalid inline images
-* are replaced with text placeholders so the request remains valid and
-* auditable.
-*/
-const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
-function invalidSnakeImage() {
+	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 {
-		type: "input_text",
-		text: `[${IMAGE_OMITTED_TEXT}]`
+		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 sanitizeValue(value) {
-	if (Array.isArray(value)) return value.map(sanitizeValue);
-	if (!isRecord(value)) return value;
-	if (value.type === "input_image" && typeof value.image_url === "string") {
-		const imageUrl = sanitizeInlineImageDataUrl(value.image_url);
-		return imageUrl ? {
-			...value,
-			image_url: imageUrl
-		} : invalidSnakeImage();
+//#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;
 	}
-	const next = {};
-	for (const [key, child] of Object.entries(value)) next[key] = sanitizeValue(child);
-	return next;
 }
-/** Sanitize inline image fields inside a Responses API payload. */
-function sanitizeResponsesImagePayload(params) {
-	if (!Array.isArray(params.input)) return params;
-	return {
-		...params,
-		input: sanitizeValue(params.input)
+/** Run a compact-endpoint request through the session's prepared stream stack. */
+async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context, options) {
+	const preparedOptions = { ...options };
+	let resolveResult;
+	let rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	const controller = {
+		claimed: false,
+		resolve: resolveResult,
+		reject: rejectResult
 	};
+	Reflect.set(preparedOptions, COMPACT_REQUEST, controller);
+	const stream = await Promise.resolve(streamFn(model, context, preparedOptions));
+	if (!controller.claimed) throw new Error("Prepared stream did not reach an OpenAI Responses transport");
+	try {
+		return await result;
+	} finally {
+		await stream.result().catch(() => void 0);
+	}
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-client.ts
@@ -2648,47 +2843,16 @@ function resolveProviderTransportTurnState(model, params) {
 		}
 	});
 }
-function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId) {
+function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId, fetchOverride) {
 	return new OpenAI({
 		apiKey,
 		baseURL: resolveOpenAIClientBaseUrl(model),
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId),
-		fetch: buildGuardedModelFetch(model),
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
 	});
 }
-async function postOpenAIResponsesCompaction(params) {
-	const response = await params.client.post("/responses/compact", {
-		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, {
-			timeoutMs: params.options?.timeoutMs,
-			maxRetries: params.options?.maxRetries
-		}),
-		body: {
-			model: params.request.model,
-			input: params.request.input
-		}
-	});
-	const output = isRecord(response) && Array.isArray(response.output) ? response.output : [];
-	const item = output.at(-1);
-	const retainedItems = output.slice(0, -1);
-	const retainedMessagesAreValid = retainedItems.every((candidate) => isRecord(candidate) && candidate.type === "message" && (candidate.role === "user" || candidate.role === "developer" || candidate.role === "system") && Array.isArray(candidate.content));
-	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" || !retainedMessagesAreValid || 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 {
-		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;
@@ -2709,9 +2873,11 @@ 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);
-				const buildRequest = async (replayMode) => {
-					let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata, replayMode);
+				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId, compactRequest ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : void 0);
+				const nativeAstra = model.id === "gpt-6-astra" && supportsNativeOpenAIResponsesEndpoint(model);
+				const asyncToolExecutionEligible = nativeAstra && options?.asyncToolExecution === true && !responsesOptions?.openclawCodeModeToolSurface;
+				const prepareRequest = async (request) => {
+					let params = request;
 					const nextParams = await options?.onPayload?.(params, model);
 					if (nextParams !== void 0) params = nextParams;
 					if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
@@ -2723,9 +2889,15 @@ function createResponsesTransportExecutor(config) {
 						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
 						assertCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
 					}
+					if (asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true && params.tools) params.tools = params.tools.map((tool) => tool.type === "function" ? {
+						...tool,
+						async: true
+					} : tool);
 					return params;
 				};
-				const params = await buildRequest("checkpoint");
+				const buildRequest = (replayMode, requestContext = context) => prepareRequest(config.buildRequest(model, requestContext, responsesOptions, turnState?.metadata, replayMode));
+				let params = await buildRequest("checkpoint");
+				const asyncTools = asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true;
 				if (compactRequest) {
 					const compacted = await postOpenAIResponsesCompaction({
 						client,
@@ -2749,13 +2921,16 @@ function createResponsesTransportExecutor(config) {
 					provider: model.provider,
 					api: model.api,
 					baseUrl: model.baseUrl
-				}) && sessionId && params.store === true && !params.previous_response_id) continuationClaim = claimOpenAIResponsesHttpContinuation({
-					sessionId,
-					apiKey,
-					baseUrl: model.baseUrl,
-					headers: buildOpenAIClientHeaders(model, context, options?.headers, turnState?.headers, sessionId),
-					request: params
-				});
+				}) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
+					continuationClaim = claimOpenAIResponsesHttpContinuation({
+						sessionId,
+						apiKey,
+						baseUrl: model.baseUrl,
+						headers: buildOpenAIClientHeaders(model, context, options?.headers, turnState?.headers, sessionId),
+						request: params
+					});
+					if (continuationClaim) params = continuationClaim.fullRequest;
+				}
 				const observePrompt = createResponsesPromptEgressObserver(responsesOptions, context.systemPrompt);
 				const requestStartedAt = Date.now();
 				let started = false;
@@ -2772,14 +2947,13 @@ function createResponsesTransportExecutor(config) {
 				firstEventAbort = firstEvent;
 				const requestOptions = buildOpenAISdkRequestOptions(model, firstEvent.signal, {
 					stream: config.streamRequest,
-					timeoutMs: options?.timeoutMs,
-					maxRetries: options?.maxRetries
+					timeoutMs: options?.timeoutMs
 				});
 				const websocketSignal = combineWebSocketTimeoutSignal(firstEvent.signal, model, requestOptions?.timeout);
 				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} requestIdHash=${redactIdentifier(options?.requestId, { len: 64 })} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
 				let continuationBaseline;
 				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
-					const { stream: responseStream } = await config.createResponseStream({
+					const { stream: responseStream } = await createResponsesStreamWithEncryptedContentRetry({
 						client,
 						request: initialRequest,
 						requestOptions,
@@ -2825,9 +2999,15 @@ function createResponsesTransportExecutor(config) {
 						headers: websocketHeaders,
 						signal: websocketSignal,
 						callerSignal: options?.signal,
-						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs
+						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs,
+						onActiveResponse: nativeAstra && params.model === "gpt-6-astra" ? options?.onActiveResponse : void 0,
+						steeringInput: (messages) => projectResponsesSteeringInput(params, () => buildRequest("checkpoint", {
+							...context,
+							messages: [...context.messages, ...messages]
+						}))
 					});
 					finishWebSocket = websocket.finish;
+					recordResponsesInputReplay(output, websocket.inputReplay);
 					observePrompt?.(websocket.request, {
 						egress: "responses-websocket",
 						payloadVariant: "initial"
@@ -2869,7 +3049,8 @@ function createResponsesTransportExecutor(config) {
 							yield* await createSseStream();
 						}
 					} };
-				} catch {
+				} catch (error) {
+					if (error instanceof OpenAIResponsesWebSocketPostDispatchError) throw error;
 					closeWebSocketForFallback("setup_failure");
 					responseStream = await createSseStream();
 				}
@@ -2884,7 +3065,8 @@ function createResponsesTransportExecutor(config) {
 						reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
 							authProfileId: responsesOptions?.authProfileId,
 							sessionId: options?.sessionId
-						})
+						}),
+						asyncToolExecution: asyncTools
 					});
 					finishWebSocket?.();
 					if (options?.signal?.aborted) throw transportAbortError(options.signal);
@@ -2933,7 +3115,6 @@ function createOpenAIResponsesTransportStreamFn() {
 		httpContinuation: true,
 		createClient: createOpenAIResponsesClient,
 		buildRequest: buildOpenAIResponsesParams,
-		createResponseStream: createResponsesStreamWithEncryptedContentRetry,
 		pricingOptions: (options, model) => ({
 			serviceTier: options?.serviceTier,
 			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
@@ -2945,27 +3126,23 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		outputApi: "azure-openai-responses",
 		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
 		createClient: createAzureOpenAIClient,
-		buildRequest: (model, context, options, metadata, replayMode) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata, replayMode),
-		createResponseStream: createResponsesStreamWithEncryptedContentRetry
+		buildRequest: (model, context, options, metadata, replayMode) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata, replayMode)
 	});
 }
-function normalizeAzureBaseUrl(baseUrl) {
-	return baseUrl.replace(/\/+$/, "");
-}
 function resolveAzureDeploymentName(model) {
 	return resolveAzureDeploymentNameFromMap({
 		modelId: model.id,
 		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
 	});
 }
-function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders) {
-	const baseURL = normalizeAzureBaseUrl(model.baseUrl);
+function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders, _sessionId, fetchOverride) {
+	const baseURL = model.baseUrl.replace(/\/+$/, "");
 	const clientOptions = {
 		apiKey,
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
 		baseURL,
-		fetch: buildGuardedModelFetch(model),
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
 	};
 	if (isOpenAICompatibleAzureResponsesBaseUrl(baseURL)) return new OpenAI(clientOptions);
@@ -3011,6 +3188,112 @@ const responsesTesting = {
 if (process.env.VITEST || false) globalThis.openclawOpenAIResponsesTransportTestApi = responsesTesting;
 //#endregion
 //#region packages/ai/src/transports/provider-compaction-replay.ts
+function isAssistantReplayMessage(message) {
+	return message.role === "assistant";
+}
+/** Resolve from prepared transport facts; never retain or return credential material. */
+function resolveCompactionReplayEligibility(model, options) {
+	if (OPENAI_RESPONSES_APIS.has(model.api)) return true;
+	return Boolean(options.apiKey?.trim()) && resolveAnthropicServerCompactionPlan(model, options.extraParams, options.apiKey).enabled;
+}
+function resolveCompactionSource(messages, model, identity) {
+	if (identity.enabled === false) return;
+	const assistants = messages.filter(isAssistantReplayMessage);
+	const selected = (() => {
+		if (OPENAI_RESPONSES_APIS.has(model.api)) {
+			const responses = resolveNewestOpenAIResponsesCompactionReplay(assistants, model, identity);
+			return responses ? {
+				family: "responses",
+				...responses
+			} : void 0;
+		}
+		if (identity.enabled !== true) return;
+		const anthropic = resolveNewestAnthropicCompaction(assistants, model, identity);
+		return anthropic ? {
+			family: "anthropic",
+			...anthropic
+		} : void 0;
+	})();
+	if (!selected) return;
+	const owner = assistants.find((message) => message === selected.owner);
+	return owner ? {
+		...selected,
+		owner
+	} : void 0;
+}
+/** Manual recovery uses the durable client compactor, never a guessed retained-user prefix. */
+function requiresCompactionReplayRefresh(messages, model, identity) {
+	const checkpoint = resolveCompactionSource(messages, model, identity);
+	return checkpoint?.family === "responses" && checkpoint.mode === "refresh-required";
+}
+/** Carry a checkpoint immediately after reference-preserving history limiting, before repair. */
+function preserveCompactionReplayWindow(source, windowed, model, identity) {
+	const checkpoint = resolveCompactionSource(source, model, identity);
+	if (!checkpoint || windowed.some((message) => message === checkpoint.owner)) return windowed;
+	const owner = checkpoint.owner;
+	const replay = checkpoint.owner.providerReplay;
+	const providerReplay = replay?.type === "openai-responses-retained-compaction" ? replay : {
+		...replay,
+		replayIndex: 0
+	};
+	const suffix = new Set(source.slice(source.indexOf(owner) + 1));
+	return [{
+		...owner,
+		content: [],
+		providerReplay
+	}, ...windowed.filter((message) => suffix.has(message))];
+}
+function estimateResponsesWindow(checkpoint, estimate) {
+	return checkpoint.output.reduce((tokens, entry) => {
+		if (entry.type === "compaction") {
+			const { encrypted_content, ...metadata } = entry;
+			return tokens + estimate.text(encrypted_content) + estimate.json(metadata);
+		}
+		const { content, ...metadata } = entry;
+		return tokens + estimate.json(metadata) + content.reduce((sum, block) => {
+			if (block.type === "input_text") {
+				const { text, ...fields } = block;
+				return sum + estimate.text(text) + estimate.json(fields);
+			}
+			if (block.type === "input_image") {
+				const { image_url: _imageUrl, ...fields } = block;
+				return sum + estimate.image() + estimate.json(block.image_url?.startsWith("data:") ? fields : block);
+			}
+			return sum + estimate.json(block);
+		}, 0);
+	}, 0);
+}
+/** Estimate the canonical prefix and its tail once, independent of unbound usage snapshots. */
+function resolveCompactionReplayPressure(messages, model, identity, estimate) {
+	const checkpoint = resolveCompactionSource(messages, model, identity);
+	if (!checkpoint) return;
+	if (checkpoint.family === "responses" && checkpoint.mode === "refresh-required") throw new CompactionReplayRefreshRequiredError();
+	const ownerIndex = messages.findIndex((message) => message === checkpoint.owner);
+	const owner = messages[ownerIndex];
+	if (!owner) return;
+	const prefixTokens = checkpoint.family === "anthropic" ? estimate.text(checkpoint.summary) : checkpoint.mode === "complete-window" ? estimateResponsesWindow(checkpoint, estimate) : estimate.text(checkpoint.item.encrypted_content);
+	const { contextUsage: _staleContextUsage, ...usage } = checkpoint.owner.usage;
+	const tail = [];
+	for (const message of messages.slice(ownerIndex + 1)) {
+		if (!isAssistantReplayMessage(message) || message.usage.contextUsage === void 0) {
+			tail.push(message);
+			continue;
+		}
+		const { contextUsage: _unboundContextUsage, ...billedUsage } = message.usage;
+		tail.push({
+			...message,
+			usage: billedUsage
+		});
+	}
+	return {
+		messages: [{
+			...owner,
+			content: checkpoint.owner.content.slice(checkpoint.replayIndex),
+			usage
+		}, ...tail],
+		prefixTokens
+	};
+}
 /** Whether provider replay state is a prefix-bound server compaction checkpoint. */
 function isCompactionReplayCheckpoint(replay) {
 	const type = replay && typeof replay === "object" ? replay.type : void 0;
@@ -3306,4 +3589,4 @@ function prepareModelForSimpleCompletion(params) {
 	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
 }
 //#endregion
-export { 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, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };
+export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicCacheControlToMessages, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isAnthropicServerToolClearingEnabled, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isDirectAnthropicModel, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };