@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/transports.mjs

@@ -1,28 +1,35 @@
 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-QkygScBs.mjs";
-import { r as createAssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { _ as normalizeLowercaseStringOrEmpty, a as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, b as isRecord, c as defaultsClaudeAdaptiveThinking, d as requiresClaudeAdaptiveThinking, f as resolveAnthropicThinkingEffort, g as hasNonEmptyString, h as usesClaudeStreamingRefusalContract, l as mapAnthropicStopReason, m as usesClaudeFable5MessagesContract, n as getAiTransportHost, o as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as applyClaudeRequestContract, u as prepareClaudeNoPrefillRequestContext, y as readStringValue } from "./host-Bl7Kgddo.mjs";
-import { n as calculateCost } from "./model-utils-Dau5dlgm.mjs";
+import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./anthropic-BQXQudmA.mjs";
+import { n as normalizeLowercaseStringOrEmpty, t as hasNonEmptyString } from "./string-coerce-fsri9iCu.mjs";
+import { r as calculateCost } from "./sanitize-unicode-BP7HLLZn.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-DF_yxOsA.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { i as canonicalizeBase64, o as stableStringify } from "./provider-error-C8mBRJDl.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-BG-1AsBI.mjs";
+import { r as asNonNegativeFiniteNumber } from "./number-coercion-H9qHik3g.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, w as uniqueStrings, y as resolveOpenAIReasoningEffortForModel } from "./openai-responses-contracts-DvILoqBk.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { a as isImageWithMediaPayload, h as stripSystemPromptCacheBoundary, n as extractToolResultBlockText, r as extractToolResultText, s as adjustMaxTokensForThinking, t as describeToolResultMediaPlaceholder, v as sortPromptCacheToolsByName } from "./tool-result-text-Dvkp2Dus.mjs";
-import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch, r as resolveModelRequestTimeoutMs, s as resolveProviderRequestPolicyConfig } from "./tool-schema-json-projection-B1b-XCn5.mjs";
-import { A as applyAnthropicPayloadPolicyToParams, C as usesFoundryBearerAuth, D as canonicalizeBase64, E as resolveAnthropicImageMediaType, M as resolveAnthropicPayloadPolicy, O as applyAnthropicCacheControlToMessages, S as omitFoundryBearerCredentialHeaders, T as normalizeAnthropicInlineContent, b as resolveAnthropicFallbackServingModelCost, c as normalizeAnthropicToolChoice, d as resolveOriginalAnthropicToolName, f as toClaudeCodeToolName, g as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, h as ANTHROPIC_SERVER_SIDE_FALLBACKS, j as resolveAnthropicEphemeralCacheControl, k as applyAnthropicEphemeralCacheControlMarkers, l as projectAnthropicTools, m as findActiveAnthropicToolTurnAssistantIndex, n as applyAnthropicMessageStartUsage, p as ANTHROPIC_OMITTED_REASONING_TEXT, s as normalizeAnthropicToolCallId, t as applyAnthropicMessageDeltaUsage, u as reconcileAnthropicToolChoice, v as applyAnthropicFallbackBoundary, w as createAnthropicInlineImageBudget, x as applyAnthropicRefusal, y as readAnthropicFallbackBoundary } from "./anthropic-usage-Ma4iX6uG.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DDZPxRfr.mjs";
-import { a as convertMessages, c as resolveOpenAICompletionsResponseFormat, d as rememberPendingCommentaryTags, f as tagPendingCommentaryText, i as finalizeOpenAICompletionsToolCalls, l as shouldOmitOllamaCompatResponseFormat, n as mapOpenAIStopReason, o as detectOpenAICompletionsCompat, r as createOpenAICompletionsToolCallDeltaNormalizer, s as resolveOpenAICompletionsCompat, t as resolveOpenAIReasoningEffortMap, u as clearPendingCommentaryText } from "./openai-reasoning-compat-DKebnIBL.mjs";
+import { C as withProviderResponseHook, E as quoteUnsafeIntegerLiterals, P as sortPromptCacheToolsByName, S as withProviderAcceptanceObserver, T as parseJsonPreservingUnsafeIntegers, _ as notifyProviderStreamOpened, a as assignTransportErrorDetails, b as sanitizeTransportPayloadText, c as createEmptyTransportUsage, d as finalizeTerminalToolCallArguments, f as finalizeTransportStream, g as notifyProviderHttpResponse, h as notifyProviderHttpMetadata, j as stripSystemPromptCacheBoundary, l as createWritableTransportEventStream, m as mergeTransportMetadata, o as coerceTransportToolCallArguments, p as mergeTransportHeaders, s as copyProviderAcceptanceObserver, t as adjustMaxTokensForThinking, u as failTransportStream, v as parseTerminalToolCallArguments, w as parseJsonObjectPreservingUnsafeIntegers, x as transportAbortError, y as sanitizeNonEmptyTransportPayloadText } from "./simple-options-oqsXB6U3.mjs";
+import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch, r as resolveModelRequestTimeoutMs, s as resolveProviderRequestPolicyConfig } from "./tool-schema-json-projection-FEr-jOoZ.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-4Zx7-aCr.mjs";
+import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, h as tagUnresolvedTextAsCommentary, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, m as tagPendingCommentaryText, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagInterruptedTextPhases, r as convertMessages, s as detectOpenAICompletionsCompat, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-9OONKyAm.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
+import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { A as normalizeResponsesFailedEvent, C as prepareOpenAIResponsesReasoningItemForReplay, D as applyServiceTierPricing, E as tagOpenAIResponsesReasoningReplayItem, F as summarizeResponsesFailedNoDetailsObservation, G as normalizeOpenAIStrictToolParameters, I as summarizeResponsesPayload, L as summarizeResponsesTools, M as stringifyRedactedEvent, N as stringifyRedactedPayload, O as buildResponsesFailedNoDetailsObservation, P as summarizeOpenAITransportError, R as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, S as isInvalidEncryptedContentError, T as stripResponsesRequestEncryptedContent, U as findOpenAIStrictToolProjectionDiagnostics, V as resolveReplayableResponsesMessageId, _t as resolveModelSseDebugMode, b as convertResponsesMessages, bt as quoteUnsafeIntegerLiterals, ct as isOpenAIGpt56Model, ft as supportsOpenAIReasoningEffort, gt as resolveModelPayloadDebugMode, ht as emitModelTransportDebug, j as safeDebugValue, k as logResponsesFailedNoDetails, lt as normalizeOpenAIReasoningEffort, mt as uniqueStrings, n as processResponsesStream, o as observeResponsesStream, ot as isOpenAIGpt54MiniModel, q as resolveOpenAIProjectedToolsStrictToolFlag, st as isOpenAIGpt55Model, t as ResponsesStreamFailure, ut as resolveOpenAIReasoningEffortForModel, v as buildOpenAIResponsesReasoningReplayMetadata, vt as parseJsonObjectPreservingUnsafeIntegers, w as resolveAzureOpenAIApiVersion, x as createResponsesStreamWithEncryptedContentRetry, y as buildResponsesInputMessage, yt as parseJsonPreservingUnsafeIntegers, z as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
-import { a as parseStrictPositiveInteger } from "./number-coercion-1Miyb5MO.mjs";
-import { C as resolveSecretSentinel, S as resolveModelHeaderSentinels$1, T as supportsModelTools, _ as isGoogleGemini3ProModel, a as failTransportStream, c as mergeTransportMetadata, d as transportAbortError, f as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, g as isGoogleGemini3FlashModel, h as isCodeModeModelVisibleToolName, i as createWritableTransportEventStream, l as sanitizeNonEmptyTransportPayloadText, m as estimateStringChars, n as coerceTransportToolCallArguments, o as finalizeTransportStream, p as createAbortError$1, r as createEmptyTransportUsage, s as mergeTransportHeaders, t as assignTransportErrorDetails, u as sanitizeTransportPayloadText, v as parseRetryAfterSeconds, w as sha256Hex, y as readResponseTextSnippet } from "./transport-stream-shared-CPNv7A3r.mjs";
-import { a as parseOpenAICompletionsUsage, c as throwIfModelStreamAborted, d as reconcileOpenAIResponsesToolChoice, i as log, l as projectOpenAITools, n as createModelStreamCooperativeScheduler, o as readOpenAICompletionsContentDeltas, r as isOpenAICompletionsThinkingEnabled, s as resolvePromptCacheKey, t as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, u as reconcileOpenAICompletionsToolChoice } from "./openai-transport-shared-Cipt7egQ.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-CGDyLWUR.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
+import { a as isGoogleGemini3FlashModel, c as readResponseTextSnippet, d as resolveModelHeaderSentinels$1, f as resolveSecretSentinel, i as isCodeModeModelVisibleToolName, l as redactIdentifier, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, s as parseRetryAfterSeconds, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-Bv0FHkd0.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, K as resolveReplayableResponsesMessageId, L as isInvalidEncryptedContentError, R as resolveAzureOpenAIApiVersion, S as summarizeResponsesPayload, U as buildOpenAIResponsesReasoningReplayMetadata, V as convertResponsesMessages, W as captureOpenAIResponsesCompaction, Y as normalizeOpenAIStrictToolParameters, Z as resolveOpenAIProjectedToolsStrictToolFlag, _ as safeDebugValue, b as summarizeOpenAITransportError, c as processResponsesStream, dt as resolveModelPayloadDebugMode, f as observeResponsesStream, ft as resolveModelSseDebugMode, g as normalizeResponsesFailedEvent, h as logResponsesFailedNoDetails, m as buildResponsesFailedNoDetailsObservation, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, q as findOpenAIStrictToolProjectionDiagnostics, ut as emitModelTransportDebug, v as stringifyRedactedEvent, x as summarizeResponsesFailedNoDetailsObservation, y as stringifyRedactedPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-Cvt5MgEm.mjs";
+import { t as codeModeToolSurfaceObserver } from "./provider-options-AvldWZt8.mjs";
+import { a as createModelStreamCooperativeScheduler, c as isOpenAICompletionsThinkingEnabled, d as parseOpenAICompletionsUsage, f as readOpenAICompletionsContentDeltas, h as throwIfModelStreamAborted, i as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, l as log, m as resolvePromptCacheKey, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIProviderAcceptanceHook, p as readOpenAICompletionsReasoningBatch, r as reconcileOpenAIResponsesToolChoice, s as createOpenAIResponseHook, t as projectOpenAITools, u as measureUtf8AppendBytes } from "./openai-tool-projection-CHGLt03m.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-5ygO2rZc.mjs";
+import { i as resolveOpenAIResponsesServerCompactionPlan, n as resolveOpenAIResponsesCompactEndpointPlan, r as resolveOpenAIResponsesPayloadPolicy, t as applyOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy-BDo8CQsx.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
+import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
+import { ResponsesWS } from "openai/resources/responses/ws.js";
 //#region packages/ai/src/transports/anthropic-transport-stream.ts
 /**
 * Native Anthropic Messages streaming transport.
@@ -59,7 +66,7 @@ function isAnthropicOAuthToken(apiKey) {
 }
 function isDirectAnthropicModel(model) {
 	if (normalizeLowercaseStringOrEmpty(model.provider) !== "anthropic") return false;
-	const endpointClass = resolveProviderEndpoint(model.baseUrl).endpointClass;
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	return endpointClass === "default" || endpointClass === "anthropic-public";
 }
 function isKimiAnthropicProvider(provider) {
@@ -74,7 +81,7 @@ function useAnthropicServerSideFallback(model) {
 	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
 }
 function supportsReasoningContentReplay(model) {
-	return resolveProviderEndpoint(model.baseUrl).endpointClass === "xiaomi-native";
+	return resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
 }
 function buildAnthropicBetaHeader(model, betaFeatures, params) {
 	if (!isDirectAnthropicModel(model)) return;
@@ -169,7 +176,7 @@ async function convertAnthropicMessages(messages, model, isOAuthToken, options)
 			continue;
 		}
 		if (msg.role === "assistant") {
-			const blocks = [];
+			const blocks = i === 0 && options.compaction ? [options.compaction] : [];
 			const reasoningContent = [];
 			let omittedThinking = false;
 			for (const block of msg.content) {
@@ -296,7 +303,7 @@ function convertAnthropicTools(tools, isOAuthToken) {
 	};
 }
 function parseAnthropicToolCallArguments(inputJson) {
-	return parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson);
+	return coerceTransportToolCallArguments(parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson));
 }
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 /** Resolve the effective Anthropic API base URL from model or environment. */
@@ -399,7 +406,7 @@ async function* parseAnthropicSseBody(body, signal) {
 }
 function createAnthropicMessagesClient(params) {
 	const url = resolveAnthropicMessagesUrl(params.baseURL);
-	return { messages: { async *stream(body, options) {
+	return { messages: { async stream(body, options) {
 		const headers = mergeTransportHeaders({
 			"content-type": "application/json",
 			"anthropic-version": "2023-06-01",
@@ -412,12 +419,10 @@ function createAnthropicMessagesClient(params) {
 			body: JSON.stringify(body),
 			signal: options?.signal
 		});
-		if (!response.ok) {
-			const detail = await readAnthropicMessagesErrorBodySnippet(response);
-			throw new Error(formatAnthropicMessagesHttpError(response, detail));
-		}
-		if (!response.body) return;
-		yield* parseAnthropicSseBody(response.body, options?.signal);
+		return {
+			response,
+			stream: response.body ? parseAnthropicSseBody(response.body, options?.signal) : []
+		};
 	} } };
 }
 function formatAnthropicMessagesHttpError(response, detail) {
@@ -528,11 +533,17 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		baseUrl: model.baseUrl,
 		cacheRetention: options?.cacheRetention,
 		enableCacheControl: true
-	});
+	}, model);
 	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
-	const messages = await convertAnthropicMessages(context.messages, model, isOAuthToken, {
+	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
+		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId
+	});
+	const messages = await convertAnthropicMessages(replayPlan.messages, model, isOAuthToken, {
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
 		cacheBreakpointOptOutMessageIndexes,
+		compaction: replayPlan.compaction,
 		replayThinkingEnabled
 	});
 	const params = {
@@ -591,7 +602,8 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, cacheBreakpointOptOutMessageIndexes);
 	return {
 		params,
-		toolProjection
+		toolProjection,
+		usedCompactionReplay: replayPlan.compaction !== void 0
 	};
 }
 function resolveAnthropicTransportOptions(model, options, apiKey) {
@@ -605,7 +617,7 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 	const reasoningModelMaxTokens = resolvePositiveAnthropicTokenLimit(model.maxTokens) ?? baseMaxTokens;
 	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
 	const reasoning = options?.reasoning === "off" && mandatoryAdaptiveThinking ? "low" : options?.reasoning;
-	const resolved = {
+	const resolved = copyProviderAcceptanceObserver(options, {
 		temperature: options?.temperature,
 		stop: options?.stop,
 		maxTokens: baseMaxTokens,
@@ -615,13 +627,16 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 		sessionId: options?.sessionId,
 		headers: options?.headers,
 		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
 		maxRetryDelayMs: options?.maxRetryDelayMs,
 		metadata: options?.metadata,
 		interleavedThinking: options?.interleavedThinking,
 		toolChoice: options?.toolChoice,
 		thinkingBudgets: options?.thinkingBudgets,
-		reasoning
-	};
+		reasoning,
+		...options?.anthropicServerCompaction === true ? { anthropicServerCompaction: true } : {},
+		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
+	});
 	if (reasoning === "off") {
 		resolved.thinkingEnabled = false;
 		return resolved;
@@ -664,6 +679,7 @@ function createAnthropicMessagesTransportStreamFn() {
 			const eventSink = refusalBuffer ?? stream;
 			let costModel = model;
 			let messageStartPromptUsage;
+			let usedCompactionReplay = false;
 			try {
 				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
 				if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
@@ -676,17 +692,29 @@ function createAnthropicMessagesTransportStreamFn() {
 					options: transportOptions
 				});
 				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions);
+				usedCompactionReplay = builtParams.usedCompactionReplay;
 				let params = builtParams.params;
 				const toolProjection = builtParams.toolProjection;
 				const nextParams = await transportOptions.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				applyClaudeRequestContract(params, model);
-				const anthropicStream = client.messages.stream({
+				const { response, stream: anthropicStream } = await client.messages.stream({
 					...params,
 					stream: true
 				}, transportOptions.signal ? { signal: transportOptions.signal } : void 0);
+				await notifyProviderHttpResponse({
+					options: transportOptions,
+					response,
+					model
+				});
+				if (!response.ok) {
+					const detail = await readAnthropicMessagesErrorBodySnippet(response);
+					throw new Error(formatAnthropicMessagesHttpError(response, detail));
+				}
 				const blocks = output.content;
 				const blockIndexes = /* @__PURE__ */ new Map();
+				const sealedToolCalls = [];
+				const compactionCapture = createCompactionCapture(output, model, transportOptions);
 				const pendingThinkingSignatures = /* @__PURE__ */ new Map();
 				const allowReasoningContentReplay = supportsReasoningContentReplay(model);
 				const reasoningContentThinkingBlocks = /* @__PURE__ */ new Map();
@@ -720,6 +748,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							partial: output
 						});
 					}
+					if (contentIndex === void 0) return false;
 					block.thinking += text;
 					block.thinkingSignature = "reasoning_content";
 					eventSink.push({
@@ -751,6 +780,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							partial: output
 						});
 					}
+					if (contentIndex === void 0) return false;
 					block.text += text;
 					eventSink.push({
 						type: "text_delta",
@@ -809,9 +839,11 @@ function createAnthropicMessagesTransportStreamFn() {
 					if (event.type === "content_block_start") {
 						const contentBlock = event.content_block;
 						const index = typeof event.index === "number" ? event.index : -1;
+						if (transportOptions.anthropicServerCompaction === true && compactionCapture.begin(index, contentBlock, output.content.length)) continue;
 						const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(contentBlock) : null;
 						if (fallbackBoundary) {
 							refusalBuffer?.discard();
+							sealedToolCalls.length = 0;
 							pendingTextEnds.length = 0;
 							blockIndexes.clear();
 							pendingThinkingSignatures.clear();
@@ -945,6 +977,7 @@ function createAnthropicMessagesTransportStreamFn() {
 					if (event.type === "content_block_delta") {
 						const delta = event.delta;
 						const eventIndex = typeof event.index === "number" ? event.index : void 0;
+						if (eventIndex !== void 0 && compactionCapture.delta(eventIndex, delta)) continue;
 						let index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
 						let block = index === void 0 ? void 0 : blocks[index];
 						if (allowReasoningContentReplay) {
@@ -953,7 +986,7 @@ 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") {
+								if (text.length > 0) if (block?.type === "text" && index !== void 0) {
 									block.text += text;
 									eventSink.push({
 										type: "text_delta",
@@ -981,6 +1014,7 @@ function createAnthropicMessagesTransportStreamFn() {
 								partial: output
 							});
 						}
+						if (index === void 0) continue;
 						if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
 							block.text += delta.text;
 							eventSink.push({
@@ -1025,6 +1059,7 @@ function createAnthropicMessagesTransportStreamFn() {
 					}
 					if (event.type === "content_block_stop") {
 						const eventIndex = typeof event.index === "number" ? event.index : void 0;
+						if (eventIndex !== void 0 && compactionCapture.complete(eventIndex)) continue;
 						const pendingSignature = eventIndex === void 0 ? void 0 : pendingThinkingSignatures.get(eventIndex);
 						if (eventIndex !== void 0) pendingThinkingSignatures.delete(eventIndex);
 						const index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
@@ -1057,12 +1092,9 @@ function createAnthropicMessagesTransportStreamFn() {
 							continue;
 						}
 						if (block.type === "toolCall") {
-							delete block.partialJson;
-							eventSink.push({
-								type: "toolcall_end",
-								contentIndex: index,
-								toolCall: block,
-								partial: output
+							sealedToolCalls.push({
+								block,
+								contentIndex: index
 							});
 							finishReasoningContentSidecars(event.index);
 						}
@@ -1079,9 +1111,20 @@ function createAnthropicMessagesTransportStreamFn() {
 						flushPendingTextEnds();
 					}
 				}
-				if (refusalBuffer && !sawMessageStop) throw new Error("Anthropic stream ended before message_stop");
+				if (isDirectAnthropicModel(model) && !sawMessageStop) throw new Error("Anthropic stream ended before message_stop");
 				if (transportOptions.signal?.aborted) throw transportAbortError(transportOptions.signal);
 				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+				if ([...blockIndexes.values()].some((index) => blocks[index]?.type === "toolCall")) throw new Error("Provider completed stream with an incomplete tool call");
+				finalizeTerminalToolCallArguments(sealedToolCalls.map(({ block }) => block), (block) => block.partialJson && block.partialJson.length > 0 ? block.partialJson : block.arguments);
+				for (const sealed of sealedToolCalls) {
+					delete sealed.block.partialJson;
+					eventSink.push({
+						type: "toolcall_end",
+						contentIndex: sealed.contentIndex,
+						toolCall: sealed.block,
+						partial: output
+					});
+				}
 				refusalBuffer?.flush();
 				if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
 				flushPendingTextEnds();
@@ -1093,7 +1136,8 @@ function createAnthropicMessagesTransportStreamFn() {
 				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,
@@ -1210,15 +1254,11 @@ const MAX_TOKENS_PARAM_KEYS = [
 	"max_completion_tokens",
 	"max_tokens"
 ];
-/** Return a finite non-negative max-token value, or undefined for invalid input. */
-function resolveNonNegativeMaxTokensParam(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
 /** Resolve the first supported max-token parameter present in a params object. */
 function resolveMaxTokensParam(params) {
 	if (!params) return;
 	for (const key of MAX_TOKENS_PARAM_KEYS) {
-		const resolved = resolveNonNegativeMaxTokensParam(params[key]);
+		const resolved = asNonNegativeFiniteNumber(params[key]);
 		if (resolved !== void 0) return resolved;
 	}
 }
@@ -1335,6 +1375,172 @@ function stripCompletionMessagesToRoleContent(messages) {
 	});
 }
 //#endregion
+//#region packages/ai/src/transports/openai-completions-host.ts
+/**
+* Chat Completions accepts Azure AI Foundry hosts in addition to traditional
+* Azure OpenAI hosts. Do not replace this with isTraditionalAzureOpenAIHost,
+* which intentionally excludes the .services.ai.azure.com Foundry suffix.
+*/
+function isAzureOpenAICompatibleHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+//#endregion
+//#region packages/ai/src/transports/openai-completions-replay.ts
+function isGoogleOpenAICompatModel(model) {
+	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
+	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
+}
+function requiresGoogleCompatToolCallThoughtSignature(model) {
+	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
+}
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
+function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
+	return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
+}
+function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
+	if (!isGoogleOpenAICompatModel(model)) return;
+	const sigById = /* @__PURE__ */ new Map();
+	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
+	for (const msg of context.messages ?? []) {
+		if (msg.role !== "assistant") continue;
+		const source = msg;
+		if (!Array.isArray(source.content)) continue;
+		for (const block of source.content) {
+			if (block.type !== "toolCall") continue;
+			const id = block.id;
+			const sig = block.thoughtSignature;
+			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
+				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
+				if (!isSameRoute && !fallbackSig) continue;
+				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
+			}
+		}
+	}
+	if (sigById.size === 0 && !fallbackSig) return;
+	for (const message of outgoingMessages) {
+		const toolCalls = message.tool_calls;
+		if (!Array.isArray(toolCalls)) continue;
+		for (const toolCall of toolCalls) {
+			const id = toolCall.id;
+			if (typeof id !== "string") continue;
+			let sig = sigById.get(id) ?? fallbackSig;
+			if (typeof sig === "string" && sig.length > 0) {
+				if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
+			}
+			if (typeof sig !== "string" || sig.length === 0) continue;
+			const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
+			toolCall.extra_content = extra;
+			const google = extra.google && typeof extra.google === "object" ? extra.google : {};
+			extra.google = google;
+			google.thought_signature = sig;
+		}
+	}
+}
+const COMPLETIONS_REASONING_REPLAY_FIELDS = [
+	"reasoning_details",
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function stripCompletionsReasoningReplayFields(record) {
+	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
+}
+function sanitizeOpenRouterReasoningReplayFields(record) {
+	const reasoningDetails = record.reasoning_details;
+	if (typeof reasoningDetails === "string") {
+		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
+		delete record.reasoning_details;
+	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
+	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
+	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
+	const reasoningText = record.reasoning_text;
+	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
+	if ("reasoning_text" in record) delete record.reasoning_text;
+}
+function sanitizeReasoningContentReplayFields(record) {
+	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
+	delete record.reasoning_details;
+	delete record.reasoning;
+	delete record.reasoning_text;
+}
+const REASONING_CONTENT_REPLAY_MODEL_IDS = /* @__PURE__ */ new Set([
+	"deepseek-v4-flash",
+	"deepseek-v4-pro",
+	"kimi-for-coding",
+	"kimi-k2.5",
+	"kimi-k2.6",
+	"kimi-k2.7-code",
+	"kimi-k2.7-code-highspeed",
+	"kimi-k3",
+	"kimi-k2-thinking",
+	"kimi-k2-thinking-turbo",
+	"mimo-v2-pro",
+	"mimo-v2-omni",
+	"mimo-v2.5",
+	"mimo-v2.5-pro",
+	"mimo-v2.6-pro"
+]);
+const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
+	"-free",
+	"-paid",
+	"-trial"
+];
+function stripReasoningContentReplayTierSuffix(modelId) {
+	for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
+	return modelId;
+}
+function getReasoningContentReplayModelIdCandidates(modelId) {
+	if (typeof modelId !== "string") return [];
+	const normalized = modelId.trim().toLowerCase();
+	if (!normalized) return [];
+	const parts = normalized.split("/").filter(Boolean);
+	const finalPart = parts[parts.length - 1] ?? normalized;
+	const candidates = [finalPart];
+	const colonParts = finalPart.split(":").filter(Boolean);
+	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
+	const baseCount = candidates.length;
+	for (let index = 0; index < baseCount; index += 1) {
+		const candidate = candidates[index];
+		if (typeof candidate !== "string") continue;
+		const stripped = stripReasoningContentReplayTierSuffix(candidate);
+		if (stripped !== candidate) candidates.push(stripped);
+	}
+	return uniqueStrings(candidates.filter(Boolean));
+}
+function shouldPreserveReasoningContentReplay(model, compat) {
+	if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
+	return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
+}
+function shouldPreserveOpenRouterReasoningReplay(model) {
+	if (model.provider !== "openrouter") return true;
+	const normalizedModelId = model.id.trim().toLowerCase();
+	return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
+}
+function shouldTrustReasoningContentReplayMetadata(model) {
+	if (!model.reasoning) return false;
+	if (model.provider.trim().toLowerCase() === "openai") return false;
+	return shouldPreserveOpenRouterReasoningReplay(model);
+}
+function sanitizeCompletionsReasoningReplayFields(messages, options) {
+	if (!Array.isArray(messages)) return;
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") continue;
+		const record = msg;
+		if (record.role !== "assistant") continue;
+		if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
+		else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
+		else stripCompletionsReasoningReplayFields(record);
+	}
+}
+function applyCompletionsReplay(outgoingMessages, context, model, compat) {
+	injectToolCallThoughtSignatures(outgoingMessages, context, model);
+	sanitizeCompletionsReasoningReplayFields(outgoingMessages, {
+		preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
+		preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
+	});
+}
+//#endregion
 //#region packages/ai/src/transports/openai-transport-params.ts
 const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
 const OPENAI_CODEX_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
@@ -1355,13 +1561,51 @@ function readCodeModePayloadToolName(tool) {
 	const fnName = readToolPayloadField(fn, "name");
 	return typeof fnName === "string" ? fnName : void 0;
 }
-function filterCodeModePayloadTools(payload, visibleToolNames) {
+function readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes) {
+	if (!isRecord(tool)) return;
+	const type = readToolPayloadField(tool, "type");
+	if (typeof type === "string" && allowedHostedToolTypes?.has(type)) {
+		try {
+			if (Object.hasOwn(tool, "name") || Object.hasOwn(tool, "function") || Object.hasOwn(tool, "functionDeclarations") || Object.hasOwn(tool, "function_declarations")) return false;
+		} catch {
+			return false;
+		}
+		return `hosted:${type}`;
+	}
+	const name = readCodeModePayloadToolName(tool);
+	return typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames) ? `client:${name}` : void 0;
+}
+function readCodeModePayloadToolIdentities(payload) {
+	if (!isRecord(payload)) return [];
+	const tools = readToolPayloadField(payload, "tools");
+	if (!Array.isArray(tools)) return [];
+	return tools.flatMap((tool) => {
+		if (!isRecord(tool)) return [];
+		const identities = [];
+		const name = readCodeModePayloadToolName(tool);
+		if (name) identities.push(`client:${name}`);
+		for (const key of ["functionDeclarations", "function_declarations"]) {
+			const declarations = readToolPayloadField(tool, key);
+			if (!Array.isArray(declarations)) continue;
+			for (const declaration of declarations) {
+				const declarationName = readCodeModePayloadToolName(declaration);
+				if (declarationName) identities.push(`client:${declarationName}`);
+			}
+		}
+		const type = readToolPayloadField(tool, "type");
+		if (typeof type === "string" && type !== "function") identities.push(`hosted:${type}`);
+		return identities;
+	});
+}
+function filterCodeModePayloadTools(payload, visibleToolNames, allowedHostedToolTypes, observer) {
 	if (!isRecord(payload)) return;
 	const tools = readToolPayloadField(payload, "tools");
 	if (!Array.isArray(tools)) return;
+	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
 	payload.tools = tools.flatMap((tool) => {
-		const name = readCodeModePayloadToolName(tool);
-		if (typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames)) return [tool];
+		const identity = readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes);
+		if (identity) return [tool];
+		if (identity === false) return [];
 		if (!isRecord(tool)) return [];
 		const filteredGroups = {};
 		for (const key of ["functionDeclarations", "function_declarations"]) {
@@ -1375,24 +1619,31 @@ function filterCodeModePayloadTools(payload, visibleToolNames) {
 		}
 		return Object.keys(filteredGroups).length > 0 ? [filteredGroups] : [];
 	});
+	if (beforeToolIdentities) observer?.({
+		beforeToolIdentities,
+		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
+	});
 }
 function resolveCodeModeResponsesVisibleToolNames(context) {
 	return new Set((context.tools ?? []).map(readCodeModePayloadToolName).filter((name) => typeof name === "string"));
 }
-function enforceCodeModeResponsesToolSurface(payload, visibleToolNames) {
+function enforceCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes, observer) {
 	if (!isRecord(payload)) return;
 	const tools = readToolPayloadField(payload, "tools");
 	if (!Array.isArray(tools)) return;
-	payload.tools = tools.filter((tool) => {
-		const name = readCodeModePayloadToolName(tool);
-		return typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames);
+	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
+	payload.tools = tools.filter((tool) => Boolean(readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes)));
+	if (beforeToolIdentities) observer?.({
+		beforeToolIdentities,
+		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
 	});
 }
-function assertCodeModeResponsesToolSurface(payload, visibleToolNames) {
+function assertCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes) {
 	const tools = isRecord(payload) ? readToolPayloadField(payload, "tools") : void 0;
 	if (!Array.isArray(tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
-	const names = tools.map(readCodeModePayloadToolName).filter((name) => typeof name === "string" && name.length > 0).toSorted((left, right) => left.localeCompare(right));
-	if (names.length >= 2 && names.length === tools.length && new Set(names).size === names.length && names.includes("exec") && names.includes("wait") && names.every((name) => isCodeModeModelVisibleToolName(name, visibleToolNames))) return;
+	const identities = tools.map((tool) => readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes));
+	const names = identities.flatMap((identity) => typeof identity === "string" && identity.startsWith("client:") ? [identity.slice(7)] : []).toSorted((left, right) => left.localeCompare(right));
+	if (names.length >= 2 && identities.every((identity) => typeof identity === "string") && new Set(identities).size === identities.length && names.includes("exec") && names.includes("wait")) return;
 	throw new Error(`Code mode payload tool surface violation: expected exec,wait plus direct-only tools; got ${names.length > 0 ? names.join(",") : "none"}`);
 }
 function buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context) {
@@ -1469,7 +1720,7 @@ function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, se
 		...optionHeaders,
 		...turnHeaders
 	};
-	const resolvedHeaders = resolveProviderRequestPolicyConfig({
+	const resolvedHeaders = resolveProviderRequestPolicyConfig(model, {
 		provider: model.provider,
 		api: model.api,
 		baseUrl: model.baseUrl,
@@ -1514,67 +1765,10 @@ function getCompat(model) {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-completions-transport.ts
-function hasToolHistory(messages) {
-	return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall"));
-}
-function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
-	const messages = params.messages;
-	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
-	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
-}
-const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
-const SSE_DONE_MAX_LINE_CHARS = 1024;
-function createSseDoneDetector() {
-	const decoder = new TextDecoder();
-	let line = "";
-	let lineOverflowed = false;
-	let sawDone = false;
-	const finishLine = () => {
-		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
-		line = "";
-		lineOverflowed = false;
-	};
-	const observeText = (text) => {
-		for (const char of text) {
-			if (char === "\n" || char === "\r") {
-				finishLine();
-				continue;
-			}
-			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
-			else lineOverflowed = true;
-		}
-	};
-	return {
-		observe(chunk) {
-			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
-		},
-		finish() {
-			if (sawDone) return;
-			observeText(decoder.decode());
-			if (line || lineOverflowed) finishLine();
-		},
-		sawDone: () => sawDone
-	};
-}
-function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, opts) {
-	const clientConfig = buildOpenAICompletionsClientConfig(model, context, optionHeaders);
-	return new OpenAI({
-		apiKey,
-		baseURL: clientConfig.baseURL,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: clientConfig.defaultHeaders,
-		defaultQuery: clientConfig.defaultQuery,
-		fetch: opts?.fetch ?? buildGuardedModelFetch(model),
-		...buildOpenAISdkClientOptions(model)
-	});
-}
-function isAzureOpenAICompatibleHost(hostname) {
-	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
-}
+//#region packages/ai/src/transports/openai-completions-params.ts
 function isKnownOpenAICompletionsEndpoint(model) {
 	if (!model.baseUrl.trim()) return true;
-	const endpointClass = resolveProviderEndpoint(model.baseUrl).endpointClass;
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
 	try {
 		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
@@ -1582,523 +1776,265 @@ function isKnownOpenAICompletionsEndpoint(model) {
 		return false;
 	}
 }
-function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
-	const headers = buildOpenAIClientHeaders(model, context, optionHeaders);
-	const defaultQuery = {};
-	let baseURL = model.baseUrl;
-	let isAzureHost = false;
-	try {
-		const parsed = new URL(model.baseUrl);
-		isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
-		parsed.searchParams.forEach((value, key) => {
-			if (value) defaultQuery[key] = value;
-		});
-		parsed.search = "";
-		baseURL = parsed.toString().replace(/\/$/, "");
-	} catch {}
-	if (isAzureHost) {
-		const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
-		if (apiVersionHeader) {
-			const apiVersion = headers[apiVersionHeader]?.trim();
-			delete headers[apiVersionHeader];
-			if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
-		}
-	}
+function resolveOpenAICompletionsReasoningEffort$1(options) {
+	return options?.reasoningEffort ?? options?.reasoning ?? "high";
+}
+function resolveOpenAICompletionsMaxTokens(model, options) {
+	if (options?.maxTokens) return {
+		maxTokens: options.maxTokens,
+		clampToModelMaxTokens: true
+	};
+	const paramsMaxTokens = resolveMaxTokensParam(model.params);
+	if (paramsMaxTokens) return {
+		maxTokens: paramsMaxTokens,
+		clampToModelMaxTokens: false
+	};
 	return {
-		baseURL,
-		defaultHeaders: headers,
-		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
+		maxTokens: model.maxTokens,
+		clampToModelMaxTokens: false
 	};
 }
-function createOpenAICompletionsTransportStreamFn() {
-	return (model, context, options) => {
-		const eventStream = createAssistantMessageEventStream();
-		const stream = eventStream;
-		(async () => {
-			const output = {
-				role: "assistant",
-				content: [],
-				api: model.api,
-				provider: model.provider,
-				model: model.id,
-				usage: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					totalTokens: 0,
-					cost: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						total: 0
-					}
-				},
-				stopReason: "stop",
-				timestamp: Date.now()
-			};
-			let firstEventAbort;
-			try {
-				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-				const doneDetector = createSseDoneDetector();
-				const baseFetch = buildGuardedModelFetch(model);
-				const doneDetectingFetch = async (url, init) => {
-					const response = await baseFetch(url, init);
-					if (!response.body || !response.ok) return response;
-					if (typeof TransformStream === "undefined" || !response.body.pipeThrough) return response;
-					const transformed = response.body.pipeThrough(new TransformStream({
-						transform(chunk, controller) {
-							doneDetector.observe(chunk);
-							controller.enqueue(chunk);
-						},
-						flush() {
-							doneDetector.finish();
-						}
-					}));
-					return new Response(transformed, {
-						headers: response.headers,
-						status: response.status,
-						statusText: response.statusText
-					});
-				};
-				const client = createOpenAICompletionsClient(model, context, apiKey, options?.headers, { fetch: doneDetectingFetch });
-				let params = buildOpenAICompletionsParams(model, context, options);
-				const nextParams = await options?.onPayload?.(params, model);
-				if (nextParams !== void 0) params = nextParams;
-				if (options?.openclawCodeModeToolSurface === true) {
-					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
-					enforceCodeModeResponsesToolSurface(params, visibleToolNames);
-					assertCodeModeResponsesToolSurface(params, visibleToolNames);
-				}
-				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
-				const emitReasoning = shouldEmitOpenAICompletionsReasoning(model, options);
-				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-				const responseStream = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, firstEventAbort.signal, {
-					timeoutMs: options?.timeoutMs,
-					maxRetries: options?.maxRetries
-				}));
-				stream.push({
-					type: "start",
-					partial: output
-				});
-				await processOpenAICompletionsStream(responseStream, output, model, stream, {
-					signal: options?.signal,
-					emitReasoning,
-					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
-					abortFirstEventStream: firstEventAbort.abort,
-					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-					sawStreamDONE: doneDetector.sawDone
-				});
-				finalizeTransportStream({
-					stream,
-					output,
-					signal: options?.signal
-				});
-			} catch (error) {
-				failTransportStream({
-					stream,
-					output,
-					signal: options?.signal,
-					error,
-					cleanup: () => {
-						output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-						finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
-					}
-				});
-			} finally {
-				firstEventAbort?.dispose();
-			}
-		})();
-		return eventStream;
-	};
+function resolveOpenAICompletionsModelMaxTokens(model) {
+	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
 }
-async function processOpenAICompletionsStream(responseStream, output, model, stream, options) {
-	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
-	const MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES = 256e3;
-	const emitReasoning = options?.emitReasoning ?? true;
-	const compat = getCompat(model);
-	const deepSeekTextFilter = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekTextFilter() : null;
-	const deepSeekToolCallRecoverer = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekDsmlToolCallRecoverer() : null;
-	const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
-	let currentBlock = null;
-	let pendingPostToolCallDeltas = [];
-	let pendingPostToolCallBytes = 0;
-	let isFlushingPendingPostToolCallDeltas = false;
-	const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
-	const toolCallBlocksById = /* @__PURE__ */ new Map();
-	const provisionalCommentaryTags = /* @__PURE__ */ new Map();
-	const toolCallBlockBytes = /* @__PURE__ */ new WeakMap();
-	const toolCallBlockIndices = /* @__PURE__ */ new WeakMap();
-	const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
-	let sawStopFinishReason = false;
-	let sawNativeToolCallDelta = false;
-	const blockIndex = () => output.content.length - 1;
-	const measureUtf8Bytes = (text) => Buffer.byteLength(text, "utf8");
-	let chunkPushedEvent = false;
-	const pushStreamEvent = (event) => {
-		chunkPushedEvent = true;
-		stream.push(event);
-	};
-	const queuePostToolCallDelta = (next) => {
-		const nextBytes = measureUtf8Bytes(next.text);
-		if (pendingPostToolCallBytes + nextBytes > MAX_POST_TOOL_CALL_BUFFER_BYTES) throw new Error("Exceeded post-tool-call delta buffer limit");
-		pendingPostToolCallBytes += nextBytes;
-		const previous = pendingPostToolCallDeltas[pendingPostToolCallDeltas.length - 1];
-		if (!previous || previous.kind !== next.kind) {
-			pendingPostToolCallDeltas.push(next);
-			return;
+const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
+const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
+function estimateOpenAICompletionsInputTokens(payload) {
+	let adjustedChars = 0;
+	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
+	if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
+	} catch {
+		adjustedChars += 1024;
+	}
+	if (payload.response_format !== void 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
+	} catch {
+		adjustedChars += 256;
+	}
+	return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
+}
+function estimateOpenAICompletionsMessagesChars(messages) {
+	if (!Array.isArray(messages)) return 0;
+	let adjustedChars = 0;
+	for (const message of messages) {
+		if (!message || typeof message !== "object") continue;
+		const record = message;
+		adjustedChars += estimateOpenAICompletionsContentChars(record.content);
+		for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
+		if (record.tool_calls !== void 0) try {
+			adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
+		} catch {
+			adjustedChars += 256;
 		}
-		if (next.kind === "thinking" && previous.kind === "thinking") {
-			if (previous.signature !== next.signature) {
-				pendingPostToolCallDeltas.push(next);
-				return;
-			}
-			previous.text += next.text;
-			return;
+	}
+	return adjustedChars;
+}
+function estimateOpenAICompletionsContentChars(value) {
+	if (typeof value === "string") return estimateStringChars(value);
+	if (!Array.isArray(value)) return 0;
+	let adjustedChars = 0;
+	for (const block of value) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type === "image_url" || record.type === "input_image") {
+			adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
+			continue;
 		}
-		previous.text += next.text;
-	};
-	const appendThinkingDeltaInternal = (reasoningDelta) => {
-		if (!currentBlock || currentBlock.type !== "thinking") {
-			currentBlock = {
-				type: "thinking",
-				thinking: "",
-				...reasoningDelta.signature ? { thinkingSignature: reasoningDelta.signature } : {}
-			};
-			output.content.push(currentBlock);
-			pushStreamEvent({
-				type: "thinking_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
+		const text = record.text;
+		if (typeof text === "string") {
+			adjustedChars += estimateStringChars(text);
+			continue;
 		}
-		currentBlock.thinking += reasoningDelta.text;
-		pushStreamEvent({
-			type: "thinking_delta",
-			contentIndex: blockIndex(),
-			delta: reasoningDelta.text,
-			partial: output
-		});
-	};
-	const appendTextDeltaInternal = (text) => {
-		if (!currentBlock || currentBlock.type !== "text") {
-			currentBlock = {
-				type: "text",
-				text: ""
-			};
-			output.content.push(currentBlock);
-			pushStreamEvent({
-				type: "text_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
+		try {
+			adjustedChars += estimateStringChars(JSON.stringify(block));
+		} catch {
+			adjustedChars += 256;
 		}
-		currentBlock.text += text;
-		pushStreamEvent({
-			type: "text_delta",
-			contentIndex: blockIndex(),
-			delta: text
-		});
-	};
-	const flushPendingPostToolCallDeltas = () => {
-		if (isFlushingPendingPostToolCallDeltas || currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
-		isFlushingPendingPostToolCallDeltas = true;
-		const bufferedDeltas = pendingPostToolCallDeltas;
-		pendingPostToolCallDeltas = [];
-		pendingPostToolCallBytes = 0;
-		for (const delta of bufferedDeltas) if (delta.kind === "text") appendTextDeltaInternal(delta.text);
-		else if (emitReasoning) appendThinkingDeltaInternal(delta);
-		isFlushingPendingPostToolCallDeltas = false;
-	};
-	const appendThinkingDelta = (reasoningDelta) => {
-		flushPendingPostToolCallDeltas();
-		appendThinkingDeltaInternal(reasoningDelta);
-	};
-	const appendTextDelta = (text) => {
-		flushPendingPostToolCallDeltas();
-		appendTextDeltaInternal(text);
+	}
+	return adjustedChars;
+}
+function resolveOpenAICompletionsEffectiveContextTokens(model) {
+	const contextTokens = model.contextTokens;
+	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
+	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
+}
+function isQwenOpenAICompletionsThinkingFormat(format) {
+	return format === "qwen" || format === "qwen-chat-template";
+}
+function setQwenChatTemplateThinking(params, enabled) {
+	const existing = params.chat_template_kwargs;
+	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
+		...existing,
+		enable_thinking: enabled
+	} : { enable_thinking: enabled };
+}
+function applyQwenOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
+	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
+	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
+	else params.payload.enable_thinking = enabled;
+	return true;
+}
+function applyTogetherOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return;
+	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
+}
+function convertTools(tools, compat, model) {
+	const projection = projectOpenAITools(tools);
+	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
+		transport: "stream",
+		supportsStrictMode: compat?.supportsStrictMode
+	}), {
+		transport: "completions",
+		model
+	});
+	return {
+		projection,
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
+			const functionTool = {
+				name: tool.name,
+				description: tool.description,
+				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
+			};
+			if (strict !== void 0) functionTool.strict = strict;
+			return {
+				type: "function",
+				function: functionTool
+			};
+		})
 	};
-	const appendVisibleTextDelta = (text) => {
-		if (!text) return;
-		if (currentBlock?.type === "toolCall") queuePostToolCallDelta({
-			kind: "text",
-			text
-		});
-		else appendTextDelta(text);
+}
+function buildOpenAICompletionsParams(model, context, options) {
+	const compat = getCompat(model);
+	const compatDetection = detectOpenAICompletionsCompat(model);
+	let messages = convertMessages(model, context.systemPrompt ? {
+		...context,
+		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
+	} : context, compat);
+	applyCompletionsReplay(messages, context, model, compat);
+	if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
+	const params = {
+		model: model.id,
+		messages: compat.requiresStringContent ? flattenCompletionMessagesToStringContent(messages) : messages,
+		stream: true
 	};
-	const appendRecoveredToolCall = (toolCall) => {
-		if (currentBlock?.type === "toolCall") {
-			currentBlock = null;
-			flushPendingPostToolCallDeltas();
+	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
+	if (compat.supportsStore) params.store = false;
+	if (compat.supportsPromptCacheKey && promptCacheKey) {
+		params.prompt_cache_key = promptCacheKey;
+		if (cacheRetention === "long" && compat.supportsLongCacheRetention) params.prompt_cache_retention = "24h";
+	}
+	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (options?.topP !== void 0) params.top_p = options.topP;
+	const responseFormat = resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
+		provider: model.provider,
+		baseUrl: model.baseUrl,
+		hasTools: () => Boolean(context.tools?.length)
+	}) ? void 0 : options?.responseFormat, compat.supportsJsonSchemaResponseFormat);
+	if (responseFormat !== void 0) params.response_format = responseFormat;
+	if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
+	if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
+	if (options?.seed !== void 0) params.seed = options.seed;
+	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
+	if (supportsModelTools(model)) {
+		if (context.tools) {
+			const converted = convertTools(context.tools, compat, model);
+			if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
+			else if (hasToolCallHistory(context.messages)) params.tools = [];
+			if (options?.toolChoice) {
+				const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, converted.projection);
+				if (toolChoice !== void 0) params.tool_choice = toolChoice;
+			} else if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
+		} else if (hasToolCallHistory(context.messages)) params.tools = [];
+		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
+			delete params.tools;
+			delete params.tool_choice;
 		}
-		rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-		const block = {
-			type: "toolCall",
-			id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
-			name: toolCall.name,
-			arguments: toolCall.arguments,
-			partialArgs: toolCall.partialArgs
-		};
-		currentBlock = block;
-		output.content.push(block);
-		toolCallBlockIndices.set(block, output.content.length - 1);
-		pushStreamEvent({
-			type: "toolcall_start",
-			contentIndex: toolCallBlockIndices.get(block) ?? -1,
-			partial: output
-		});
-		pushStreamEvent({
-			type: "toolcall_delta",
-			contentIndex: toolCallBlockIndices.get(block) ?? -1,
-			delta: toolCall.partialArgs,
-			partial: output
-		});
-	};
-	const appendFilteredVisibleTextDelta = (text) => {
-		const recoveredParts = deepSeekToolCallRecoverer?.push(text) ?? [{
-			kind: "text",
-			text
-		}];
-		for (const recoveredPart of recoveredParts) {
-			if (recoveredPart.kind === "toolCall") {
-				appendRecoveredToolCall(recoveredPart);
-				continue;
-			}
-			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
-			for (const part of parts) appendVisibleTextDelta(part);
+	}
+	{
+		const maxTokenBudget = resolveOpenAICompletionsMaxTokens(model, options);
+		const effectiveMaxTokens = maxTokenBudget.maxTokens;
+		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
+		let clampedMaxTokens = effectiveMaxTokens;
+		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
+		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
+			clampedMaxTokens = modelMaxTokens;
+			emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
 		}
-	};
-	const flushDeepSeekToolCallRecovererAtEnd = () => {
-		const recoveredParts = deepSeekToolCallRecoverer?.flush();
-		if (!recoveredParts) return;
-		for (const recoveredPart of recoveredParts) {
-			if (recoveredPart.kind === "toolCall") {
-				appendRecoveredToolCall(recoveredPart);
-				continue;
+		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
+			const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
+			const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
+			if (clampedMaxTokens > remainingBudget) {
+				clampedMaxTokens = remainingBudget;
+				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
 			}
-			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
-			for (const part of parts) appendVisibleTextDelta(part);
 		}
+		if (clampedMaxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
+		else params.max_completion_tokens = clampedMaxTokens;
+	}
+	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort$1(options);
+	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: completionsReasoningEffort,
+		fallbackMap: compat.reasoningEffortMap
+	}) : void 0;
+	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
+	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
+	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	applyTogetherOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
+	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
+	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
+	return params;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-completions-dsml.ts
+const DEEPSEEK_DSML_BARS = ["|", "｜"];
+const DEEPSEEK_DSML_TOOL_KINDS = [
+	"tool_calls",
+	"tool_call",
+	"function_calls"
+];
+const DEEPSEEK_DSML_TOOL_OPEN_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
+const DEEPSEEK_DSML_TOOL_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
+const DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES = DEEPSEEK_DSML_BARS.map((bar) => `<${bar}DSML${bar}invoke`);
+const DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.map((bar) => `</${bar}DSML${bar}invoke>`);
+const DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length));
+const DEEPSEEK_DSML_RECOVERY_MAX_BOUNDARY_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_TOOL_CLOSE_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS.map((token) => token.length));
+const MAX_DSML_RECOVERY_BUFFER_BYTES = 256e3;
+const DEEPSEEK_DSML_SCAN_BATCH_CHARS = 64 * 1024;
+function createDsmlRecoverer() {
+	let buffer = "";
+	let bufferBytes = 0;
+	let bufferEndsWithHighSurrogate = false;
+	let pendingScanChars = 0;
+	let activeOpenToken = null;
+	let blockScanState = {
+		offset: 0,
+		mode: "outer",
+		invokeOpenStart: -1
 	};
-	const flushDeepSeekTextFilterAtEnd = () => {
-		const parts = deepSeekTextFilter?.flush();
-		if (!parts) return;
-		for (const part of parts) appendVisibleTextDelta(part);
-	};
-	const appendRoutedContentDelta = (delta) => {
-		if (delta.kind === "text") {
-			appendFilteredVisibleTextDelta(delta.text);
-			return;
-		}
-		if (!emitReasoning) return;
-		if (currentBlock?.type === "toolCall") queuePostToolCallDelta(delta);
-		else appendThinkingDelta(delta);
-	};
-	const appendPartitionedVisibleDelta = (delta) => {
-		if (delta.kind === "text") appendFilteredVisibleTextDelta(delta.text);
-	};
-	const emitReasoningUsageActivity = (hasReasoningUsageActivity) => {
-		if (!hasReasoningUsageActivity || chunkPushedEvent || !emitReasoning) return;
-		const latestBlock = output.content[output.content.length - 1];
-		if (currentBlock?.type === "text" || currentBlock?.type === "toolCall") return;
-		if (latestBlock?.type === "text" || latestBlock?.type === "toolCall") return;
-		appendThinkingDelta({ text: "" });
-	};
-	const flushReasoningTagTextPartitionerAtEnd = () => {
-		for (const delta of reasoningTagTextPartitioner.flush()) appendPartitionedVisibleDelta(delta);
-	};
-	const cooperativeScheduler = createModelStreamCooperativeScheduler(options?.signal);
-	const guardedStream = withFirstStreamEventTimeout(responseStream, {
-		provider: model.provider,
-		api: model.api,
-		model: model.id,
-		timeoutMs: options?.firstEventTimeoutMs ?? 0,
-		stage: "completions",
-		abort: options?.abortFirstEventStream,
-		onTimeout: options?.onFirstEventTimeout,
-		hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
-	});
-	for await (const rawChunk of guardedStream) {
-		throwIfModelStreamAborted(options?.signal);
-		chunkPushedEvent = false;
-		if (!rawChunk || typeof rawChunk !== "object") {
-			await cooperativeScheduler.afterEvent();
-			continue;
-		}
-		notifyLlmRequestActivity(options?.signal);
-		const chunk = rawChunk;
-		output.responseId ||= chunk.id;
-		let hasReasoningUsageActivity = false;
-		if (chunk.usage) {
-			output.usage = parseOpenAICompletionsUsage(chunk.usage, model);
-			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(chunk.usage);
-		}
-		const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
-		if (!choice) {
-			emitReasoningUsageActivity(hasReasoningUsageActivity);
-			await cooperativeScheduler.afterEvent();
-			continue;
-		}
-		const choiceUsage = choice.usage;
-		if (!chunk.usage && choiceUsage) {
-			output.usage = parseOpenAICompletionsUsage(choiceUsage, model);
-			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(choiceUsage);
-		}
-		if (choice.finish_reason) {
-			const finishReasonResult = mapOpenAIStopReason(choice.finish_reason, { allowSingularToolCall: true });
-			output.stopReason = finishReasonResult.stopReason;
-			if (finishReasonResult.stopReason === "stop") sawStopFinishReason = true;
-			if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
-		}
-		const rawChoiceDelta = choice.delta ?? choice.message;
-		if (!rawChoiceDelta) {
-			emitReasoningUsageActivity(hasReasoningUsageActivity);
-			await cooperativeScheduler.afterEvent();
-			continue;
-		}
-		for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
-			const choiceDelta = normalizedDelta.delta;
-			const reasoningDeltas = getCompletionsReasoningDeltas(choiceDelta, compat.visibleReasoningDetailTypes);
-			const hasMirroredReasoning = reasoningDeltas.some((delta) => delta.kind === "thinking");
-			if (hasMirroredReasoning) reasoningTagTextPartitioner.markStrict();
-			const contentDeltas = readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, reasoningDeltas.filter((reasoningDelta) => reasoningDelta.kind === "thinking").map((reasoningDelta) => reasoningDelta.text));
-			const appendReasoningDeltas = () => {
-				for (const reasoningDelta of reasoningDeltas) {
-					if (reasoningDelta.kind === "thinking" && !emitReasoning) continue;
-					if (currentBlock?.type === "toolCall") {
-						queuePostToolCallDelta({ ...reasoningDelta });
-						continue;
-					}
-					if (reasoningDelta.kind === "text") appendTextDelta(reasoningDelta.text);
-					else if (emitReasoning) appendThinkingDelta(reasoningDelta);
-				}
-			};
-			if (hasMirroredReasoning) appendReasoningDeltas();
-			for (const contentDelta of contentDeltas) if (contentDelta.kind === "text") {
-				const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(contentDelta.text) : reasoningTagTextPartitioner.pushVisible(contentDelta.text);
-				for (const routedDelta of routedDeltas) appendPartitionedVisibleDelta(routedDelta);
-			} else {
-				if (reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
-				appendRoutedContentDelta(contentDelta);
-			}
-			if (!hasMirroredReasoning) appendReasoningDeltas();
-			const toolCallDeltas = normalizedDelta.toolCalls;
-			if (toolCallDeltas.length > 0) {
-				sawNativeToolCallDelta = true;
-				flushReasoningTagTextPartitionerAtEnd();
-				rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-				for (const toolCall of toolCallDeltas) {
-					const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
-					let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
-					if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
-					if (!block) {
-						if (currentBlock?.type === "toolCall") {
-							currentBlock = null;
-							flushPendingPostToolCallDeltas();
-						}
-						const initialSig = extractGoogleThoughtSignature(toolCall);
-						block = {
-							type: "toolCall",
-							id: toolCall.id || "",
-							name: toolCall.function?.name || "",
-							arguments: {},
-							partialArgs: "",
-							...initialSig ? { thoughtSignature: initialSig } : {}
-						};
-						output.content.push(block);
-						toolCallBlockIndices.set(block, output.content.length - 1);
-						pushStreamEvent({
-							type: "toolcall_start",
-							contentIndex: toolCallBlockIndices.get(block) ?? -1,
-							partial: output
-						});
-					}
-					if (streamIndex !== void 0 && !toolCallBlocksByIndex.has(streamIndex)) toolCallBlocksByIndex.set(streamIndex, block);
-					if (toolCall.id) {
-						block.id = toolCall.id;
-						toolCallBlocksById.set(toolCall.id, block);
-					}
-					currentBlock = block;
-					if (toolCall.function?.name) block.name = toolCall.function.name;
-					const deltaSig = extractGoogleThoughtSignature(toolCall);
-					if (deltaSig) block.thoughtSignature = deltaSig;
-					if (toolCall.function?.arguments) {
-						const nextArgumentBytes = measureUtf8Bytes(toolCall.function.arguments);
-						const currentBlockArgBytes = toolCallBlockBytes.get(block) ?? 0;
-						if (currentBlockArgBytes + nextArgumentBytes > MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
-						toolCallBlockBytes.set(block, currentBlockArgBytes + nextArgumentBytes);
-						block.partialArgs += toolCall.function.arguments;
-						block.arguments = parseStreamingJson(block.partialArgs);
-						pushStreamEvent({
-							type: "toolcall_delta",
-							contentIndex: toolCallBlockIndices.get(block) ?? -1,
-							delta: toolCall.function.arguments,
-							partial: output
-						});
-					}
-				}
-			}
-		}
-		flushPendingPostToolCallDeltas();
-		emitReasoningUsageActivity(hasReasoningUsageActivity);
-		await cooperativeScheduler.afterEvent();
-	}
-	flushReasoningTagTextPartitionerAtEnd();
-	flushDeepSeekToolCallRecovererAtEnd();
-	flushDeepSeekTextFilterAtEnd();
-	currentBlock = null;
-	flushPendingPostToolCallDeltas();
-	finalizeOpenAICompletionsToolCalls(output, {
-		allowSilentToolCallPromotion: sawStopFinishReason || sawNativeToolCallDelta && (options?.sawStreamDONE?.() ?? false),
-		onConfirmedToolCall(block, contentIndex) {
-			pushStreamEvent({
-				type: "toolcall_end",
-				contentIndex,
-				toolCall: block,
-				partial: output
-			});
-		}
-	});
-	if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
-	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
-}
-function shouldFilterDeepSeekDsmlText(compat) {
-	return compat.thinkingFormat === "deepseek";
-}
-const DEEPSEEK_DSML_BARS = ["|", "｜"];
-const DEEPSEEK_DSML_TOOL_KINDS = [
-	"tool_calls",
-	"tool_call",
-	"function_calls"
-];
-const DEEPSEEK_DSML_TOOL_OPEN_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
-const DEEPSEEK_DSML_TOOL_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
-const DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES = DEEPSEEK_DSML_BARS.map((bar) => `<${bar}DSML${bar}invoke`);
-const DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.map((bar) => `</${bar}DSML${bar}invoke>`);
-const DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length));
-const DEEPSEEK_DSML_RECOVERY_MAX_BOUNDARY_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_TOOL_CLOSE_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS.map((token) => token.length));
-const MAX_DSML_RECOVERY_BUFFER_BYTES = 256e3;
-const DEEPSEEK_DSML_SCAN_BATCH_CHARS = 64 * 1024;
-function createDeepSeekDsmlToolCallRecoverer() {
-	let buffer = "";
-	let bufferBytes = 0;
-	let bufferEndsWithHighSurrogate = false;
-	let pendingScanChars = 0;
-	let activeOpenToken = null;
-	let blockScanState = {
-		offset: 0,
-		mode: "outer",
-		invokeOpenStart: -1
-	};
-	const resetBlockScan = () => {
-		activeOpenToken = null;
-		pendingScanChars = 0;
-		blockScanState = {
-			offset: 0,
-			mode: "outer",
-			invokeOpenStart: -1
-		};
+	const resetBlockScan = () => {
+		activeOpenToken = null;
+		pendingScanChars = 0;
+		blockScanState = {
+			offset: 0,
+			mode: "outer",
+			invokeOpenStart: -1
+		};
 	};
 	const consume = (final) => {
 		const output = [];
@@ -2180,7 +2116,7 @@ function createDeepSeekDsmlToolCallRecoverer() {
 	};
 	return {
 		push(chunk) {
-			const append = utf8ByteLengthForAppend(bufferEndsWithHighSurrogate, chunk);
+			const append = measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk);
 			bufferBytes += append.bytes;
 			bufferEndsWithHighSurrogate = append.endsWithHighSurrogate;
 			buffer += chunk;
@@ -2336,20 +2272,6 @@ function scanDeepSeekDsmlToolBlock(text, closeToken, contentStartIndex, state) {
 	}
 	return { kind: "incomplete" };
 }
-function utf8ByteLengthForAppend(bufferEndsWithHighSurrogate, chunk) {
-	let bytes = Buffer.byteLength(chunk, "utf8");
-	if (!chunk) return {
-		bytes,
-		endsWithHighSurrogate: bufferEndsWithHighSurrogate
-	};
-	const nextCodeUnit = chunk.charCodeAt(0);
-	if (bufferEndsWithHighSurrogate && nextCodeUnit >= 56320 && nextCodeUnit <= 57343) bytes -= 2;
-	const finalCodeUnit = chunk.charCodeAt(chunk.length - 1);
-	return {
-		bytes,
-		endsWithHighSurrogate: finalCodeUnit >= 55296 && finalCodeUnit <= 56319
-	};
-}
 function longestDeepSeekDsmlToolOpenPrefixSuffixLength(text) {
 	const maxLength = Math.min(text.length, DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN - 1);
 	for (let length = maxLength; length > 0; length -= 1) {
@@ -2358,17 +2280,61 @@ function longestDeepSeekDsmlToolOpenPrefixSuffixLength(text) {
 	}
 	return 0;
 }
-function getCompletionsReasoningDeltas(delta, visibleReasoningDetailTypes) {
-	const output = [];
-	const pushDelta = (next) => {
-		const previous = output[output.length - 1];
-		if (!previous || previous.kind !== next.kind) {
-			output.push(next);
+//#endregion
+//#region packages/ai/src/transports/openai-completions-stream.ts
+function extractToolCallThoughtSignature(toolCall) {
+	const tc = toolCall;
+	if (!tc) return;
+	const fromExtra = (tc.extra_content?.google)?.thought_signature;
+	if (typeof fromExtra === "string" && fromExtra.length > 0) return fromExtra;
+	const fromFunction = tc.function?.thought_signature;
+	if (typeof fromFunction === "string" && fromFunction.length > 0) return fromFunction;
+	const fromToolCall = tc.thought_signature;
+	return typeof fromToolCall === "string" && fromToolCall.length > 0 ? fromToolCall : void 0;
+}
+async function processCompletionsStream(responseStream, output, model, stream, options) {
+	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
+	const emitReasoning = options?.emitReasoning ?? true;
+	const compat = getCompat(model);
+	const visibleReasoningDetailTypes = new Set(compat.visibleReasoningDetailTypes);
+	const shouldFilterDeepSeekDsmlText = compat.thinkingFormat === "deepseek";
+	const deepSeekTextFilter = shouldFilterDeepSeekDsmlText ? createDeepSeekTextFilter() : null;
+	const deepSeekToolCallRecoverer = shouldFilterDeepSeekDsmlText ? createDsmlRecoverer() : null;
+	const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
+	let currentBlock = null;
+	let currentTextSource;
+	let pendingInterruptedTextBlock = null;
+	let confirmedInterruptedTextBlock = null;
+	let pendingPostToolCallDeltas = [];
+	let pendingPostToolCallBytes = 0;
+	let isFlushingPendingPostToolCallDeltas = false;
+	const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
+	const toolCallBlocksById = /* @__PURE__ */ new Map();
+	const provisionalCommentaryTags = /* @__PURE__ */ new Map();
+	const toolCallBlockIndices = /* @__PURE__ */ new WeakMap();
+	let explicitVisibleTextBlocks;
+	const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
+	let sawStopFinishReason = false;
+	let sawNativeToolCallDelta = false;
+	const blockIndex = () => output.content.length - 1;
+	const measureUtf8Bytes = (text) => Buffer.byteLength(text, "utf8");
+	let chunkPushedEvent = false;
+	const pushStreamEvent = (event) => {
+		chunkPushedEvent = true;
+		stream.push(event);
+	};
+	const queuePostToolCallDelta = (next) => {
+		const nextBytes = measureUtf8Bytes(next.text);
+		if (pendingPostToolCallBytes + nextBytes > MAX_POST_TOOL_CALL_BUFFER_BYTES) throw new Error("Exceeded post-tool-call delta buffer limit");
+		pendingPostToolCallBytes += nextBytes;
+		const previous = pendingPostToolCallDeltas[pendingPostToolCallDeltas.length - 1];
+		if (!previous || previous.kind !== next.kind || previous.kind === "text" && next.kind === "text" && previous.source !== next.source) {
+			pendingPostToolCallDeltas.push(next);
 			return;
 		}
 		if (next.kind === "thinking" && previous.kind === "thinking") {
 			if (previous.signature !== next.signature) {
-				output.push(next);
+				pendingPostToolCallDeltas.push(next);
 				return;
 			}
 			previous.text += next.text;
@@ -2376,646 +2342,701 @@ function getCompletionsReasoningDeltas(delta, visibleReasoningDetailTypes) {
 		}
 		previous.text += next.text;
 	};
-	const reasoningDetails = delta.reasoning_details;
-	let usedReasoningThinkingDetails = false;
-	if (Array.isArray(reasoningDetails)) {
-		const visibleTypes = new Set(visibleReasoningDetailTypes);
-		for (const item of reasoningDetails) {
-			const detail = item;
-			if (typeof detail.text !== "string" || !detail.text) continue;
-			if (detail.type === "reasoning.text") {
-				usedReasoningThinkingDetails = true;
-				pushDelta({
-					kind: "thinking",
-					signature: "reasoning_details",
-					text: detail.text
-				});
-				continue;
-			}
-			if (typeof detail.type === "string" && visibleTypes.has(detail.type)) pushDelta({
-				kind: "text",
-				text: detail.text
+	const appendThinkingDeltaInternal = (reasoningDelta) => {
+		if (!currentBlock || currentBlock.type !== "thinking") {
+			currentBlock = {
+				type: "thinking",
+				thinking: "",
+				...reasoningDelta.signature ? { thinkingSignature: reasoningDelta.signature } : {}
+			};
+			output.content.push(currentBlock);
+			pushStreamEvent({
+				type: "thinking_start",
+				contentIndex: blockIndex(),
+				partial: output
 			});
 		}
-	}
-	if (!usedReasoningThinkingDetails) for (const field of [
-		"reasoning_content",
-		"reasoning",
-		"reasoning_text"
-	]) {
-		const value = delta[field];
-		if (typeof value === "string" && value.length > 0) {
-			pushDelta({
-				kind: "thinking",
-				signature: field,
-				text: value
+		currentBlock.thinking += reasoningDelta.text;
+		pushStreamEvent({
+			type: "thinking_delta",
+			contentIndex: blockIndex(),
+			delta: reasoningDelta.text,
+			partial: output
+		});
+	};
+	const appendTextDeltaInternal = (text, source) => {
+		if (currentBlock?.type === "text" && currentTextSource !== source) currentBlock = null;
+		if (!currentBlock || currentBlock.type !== "text") {
+			currentBlock = {
+				type: "text",
+				text: ""
+			};
+			currentTextSource = source;
+			if (source === "reasoning_detail") (explicitVisibleTextBlocks ??= /* @__PURE__ */ new Set()).add(currentBlock);
+			output.content.push(currentBlock);
+			pushStreamEvent({
+				type: "text_start",
+				contentIndex: blockIndex(),
+				partial: output
 			});
-			break;
 		}
-	}
-	return output;
-}
-function resolveOpenAICompletionsReasoningEffort(options) {
-	return options?.reasoningEffort ?? options?.reasoning ?? "high";
-}
-function shouldEmitOpenAICompletionsReasoning(model, options) {
-	if (!model.reasoning) return false;
-	const effort = resolveOpenAICompletionsReasoningEffort(options);
-	if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
-	return true;
-}
-function shouldEmitOpenAICompletionsReasoningForModel(model, options) {
-	return shouldEmitOpenAICompletionsReasoning(model, options);
-}
-function resolveOpenAICompletionsMaxTokens(model, options) {
-	if (options?.maxTokens) return {
-		maxTokens: options.maxTokens,
-		clampToModelMaxTokens: true
+		currentBlock.text += text;
+		if (pendingInterruptedTextBlock && text.trim()) {
+			confirmedInterruptedTextBlock = pendingInterruptedTextBlock;
+			pendingInterruptedTextBlock = null;
+		}
+		pushStreamEvent({
+			type: "text_delta",
+			contentIndex: blockIndex(),
+			delta: text
+		});
 	};
-	const paramsMaxTokens = resolveMaxTokensParam(model.params);
-	if (paramsMaxTokens) return {
-		maxTokens: paramsMaxTokens,
-		clampToModelMaxTokens: false
+	const flushPendingPostToolCallDeltas = () => {
+		if (isFlushingPendingPostToolCallDeltas || currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
+		isFlushingPendingPostToolCallDeltas = true;
+		const bufferedDeltas = pendingPostToolCallDeltas;
+		pendingPostToolCallDeltas = [];
+		pendingPostToolCallBytes = 0;
+		for (const delta of bufferedDeltas) if (delta.kind === "text") appendTextDeltaInternal(delta.text, delta.source);
+		else if (emitReasoning) appendThinkingDeltaInternal(delta);
+		isFlushingPendingPostToolCallDeltas = false;
 	};
-	return {
-		maxTokens: model.maxTokens,
-		clampToModelMaxTokens: false
+	const appendThinkingDelta = (reasoningDelta) => {
+		flushPendingPostToolCallDeltas();
+		appendThinkingDeltaInternal(reasoningDelta);
 	};
-}
-function resolveOpenAICompletionsModelMaxTokens(model) {
-	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
-}
-const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
-const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
-function estimateOpenAICompletionsInputTokens(payload) {
-	let adjustedChars = 0;
-	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
-	if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
-		adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
-	} catch {
-		adjustedChars += 1024;
-	}
-	if (payload.response_format !== void 0) try {
-		adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
-	} catch {
-		adjustedChars += 256;
-	}
-	return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
-}
-function estimateOpenAICompletionsMessagesChars(messages) {
-	if (!Array.isArray(messages)) return 0;
-	let adjustedChars = 0;
-	for (const message of messages) {
-		if (!message || typeof message !== "object") continue;
-		const record = message;
-		adjustedChars += estimateOpenAICompletionsContentChars(record.content);
-		for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
-		if (record.tool_calls !== void 0) try {
-			adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
-		} catch {
-			adjustedChars += 256;
+	const appendTextDelta = (text, source) => {
+		flushPendingPostToolCallDeltas();
+		appendTextDeltaInternal(text, source);
+	};
+	const appendVisibleTextDelta = (text) => {
+		if (!text) return;
+		if (currentBlock?.type === "toolCall") queuePostToolCallDelta({
+			kind: "text",
+			text
+		});
+		else appendTextDelta(text);
+	};
+	const appendReasoningDeltas = (reasoningDeltas) => {
+		for (const reasoningDelta of reasoningDeltas) {
+			if (reasoningDelta.kind === "thinking" && !emitReasoning) continue;
+			if (currentBlock?.type === "toolCall") {
+				queuePostToolCallDelta({ ...reasoningDelta });
+				continue;
+			}
+			if (reasoningDelta.kind === "text") appendTextDelta(reasoningDelta.text, reasoningDelta.source);
+			else if (emitReasoning) appendThinkingDelta(reasoningDelta);
 		}
-	}
-	return adjustedChars;
-}
-function estimateOpenAICompletionsContentChars(value) {
-	if (typeof value === "string") return estimateStringChars(value);
-	if (!Array.isArray(value)) return 0;
-	let adjustedChars = 0;
-	for (const block of value) {
-		if (!block || typeof block !== "object") continue;
-		const record = block;
-		if (record.type === "image_url" || record.type === "input_image") {
-			adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
+	};
+	const appendRecoveredToolCall = (toolCall) => {
+		if (currentBlock?.type === "toolCall") {
+			currentBlock = null;
+			flushPendingPostToolCallDeltas();
+		}
+		rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
+		const block = {
+			type: "toolCall",
+			id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+			name: toolCall.name,
+			arguments: toolCall.arguments,
+			partialArgs: toolCall.partialArgs
+		};
+		currentBlock = block;
+		output.content.push(block);
+		toolCallBlockIndices.set(block, output.content.length - 1);
+		pushStreamEvent({
+			type: "toolcall_start",
+			contentIndex: toolCallBlockIndices.get(block) ?? -1,
+			partial: output
+		});
+		pushStreamEvent({
+			type: "toolcall_delta",
+			contentIndex: toolCallBlockIndices.get(block) ?? -1,
+			delta: toolCall.partialArgs,
+			partial: output
+		});
+	};
+	const appendFilteredVisibleTextDelta = (text) => {
+		const recoveredParts = deepSeekToolCallRecoverer?.push(text) ?? [{
+			kind: "text",
+			text
+		}];
+		for (const recoveredPart of recoveredParts) {
+			if (recoveredPart.kind === "toolCall") {
+				appendRecoveredToolCall(recoveredPart);
+				continue;
+			}
+			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
+			for (const part of parts) appendVisibleTextDelta(part);
+		}
+	};
+	const flushDeepSeekToolCallRecovererAtEnd = () => {
+		const recoveredParts = deepSeekToolCallRecoverer?.flush();
+		if (!recoveredParts) return;
+		for (const recoveredPart of recoveredParts) {
+			if (recoveredPart.kind === "toolCall") {
+				appendRecoveredToolCall(recoveredPart);
+				continue;
+			}
+			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
+			for (const part of parts) appendVisibleTextDelta(part);
+		}
+	};
+	const flushDeepSeekTextFilterAtEnd = () => {
+		const parts = deepSeekTextFilter?.flush();
+		if (!parts) return;
+		for (const part of parts) appendVisibleTextDelta(part);
+	};
+	const appendRoutedContentDelta = (delta) => {
+		if (delta.kind === "text") {
+			appendFilteredVisibleTextDelta(delta.text);
+			return;
+		}
+		if (!emitReasoning) return;
+		if (currentBlock?.type === "toolCall") queuePostToolCallDelta(delta);
+		else appendThinkingDelta(delta);
+	};
+	const appendPartitionedVisibleDelta = (delta) => {
+		if (delta.kind === "text") appendFilteredVisibleTextDelta(delta.text);
+	};
+	const emitReasoningUsageActivity = (hasReasoningUsageActivity) => {
+		if (!hasReasoningUsageActivity || chunkPushedEvent || !emitReasoning) return;
+		const latestBlock = output.content[output.content.length - 1];
+		if (currentBlock?.type === "text" || currentBlock?.type === "toolCall") return;
+		if (latestBlock?.type === "text" || latestBlock?.type === "toolCall") return;
+		appendThinkingDelta({ text: "" });
+	};
+	const flushReasoningTagTextPartitioner = () => {
+		for (const delta of reasoningTagTextPartitioner.flush()) appendPartitionedVisibleDelta(delta);
+	};
+	const sealTextBeforeReasoning = () => {
+		if (currentBlock?.type !== "text" && !reasoningTagTextPartitioner.hasPending()) return;
+		flushReasoningTagTextPartitioner();
+		if (currentBlock?.type !== "text") return;
+		if (currentTextSource !== "reasoning_detail" && currentBlock.text.trim()) pendingInterruptedTextBlock = currentBlock;
+		currentBlock = null;
+		currentTextSource = void 0;
+	};
+	const beginReasoning = (hasFollowingVisibleText, forceStrict = false) => {
+		if (!output.openclawDelivery?.textPhaseRequiresTerminal) output.openclawDelivery = {
+			...output.openclawDelivery,
+			textPhaseRequiresTerminal: true
+		};
+		if (forceStrict || reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
+		if (!hasFollowingVisibleText || !reasoningTagTextPartitioner.hasPendingSyntax()) sealTextBeforeReasoning();
+	};
+	const cooperativeScheduler = createModelStreamCooperativeScheduler(options?.signal);
+	const guardedStream = withFirstStreamEventTimeout(responseStream, {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		timeoutMs: options?.firstEventTimeoutMs ?? 0,
+		stage: "completions",
+		abort: options?.abortFirstEventStream,
+		onTimeout: options?.onFirstEventTimeout,
+		hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
+	});
+	for await (const rawChunk of guardedStream) {
+		throwIfModelStreamAborted(options?.signal);
+		chunkPushedEvent = false;
+		if (!rawChunk || typeof rawChunk !== "object") {
+			await cooperativeScheduler.afterEvent();
 			continue;
 		}
-		const text = record.text;
-		if (typeof text === "string") {
-			adjustedChars += estimateStringChars(text);
+		notifyLlmRequestActivity(options?.signal);
+		const chunk = rawChunk;
+		output.responseId ||= chunk.id;
+		let hasReasoningUsageActivity = false;
+		if (chunk.usage) {
+			output.usage = parseOpenAICompletionsUsage(chunk.usage, model);
+			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(chunk.usage);
+		}
+		const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
+		if (!choice) {
+			emitReasoningUsageActivity(hasReasoningUsageActivity);
+			await cooperativeScheduler.afterEvent();
 			continue;
 		}
-		try {
-			adjustedChars += estimateStringChars(JSON.stringify(block));
-		} catch {
-			adjustedChars += 256;
+		const choiceUsage = choice.usage;
+		if (!chunk.usage && choiceUsage) {
+			output.usage = parseOpenAICompletionsUsage(choiceUsage, model);
+			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(choiceUsage);
 		}
-	}
-	return adjustedChars;
-}
-function resolveOpenAICompletionsEffectiveContextTokens(model) {
-	const contextTokens = model.contextTokens;
-	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
-	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
-}
-function isQwenOpenAICompletionsThinkingFormat(format) {
-	return format === "qwen" || format === "qwen-chat-template";
-}
-function setQwenChatTemplateThinking(params, enabled) {
-	const existing = params.chat_template_kwargs;
-	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
-		...existing,
-		enable_thinking: enabled
-	} : { enable_thinking: enabled };
-}
-function applyQwenOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
-	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
-	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
-	else params.payload.enable_thinking = enabled;
-	return true;
-}
-function applyTogetherOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return false;
-	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
-	return true;
-}
-function convertTools(tools, compat, model) {
-	const projection = projectOpenAITools(tools);
-	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
-		transport: "stream",
-		supportsStrictMode: compat?.supportsStrictMode
-	}), {
-		transport: "completions",
-		model
-	});
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const functionTool = {
-				name: tool.name,
-				description: tool.description,
-				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
-			};
-			if (strict !== void 0) functionTool.strict = strict;
-			return {
-				type: "function",
-				function: functionTool
-			};
-		})
-	};
-}
-function extractGoogleThoughtSignature(toolCall) {
-	const tc = toolCall;
-	if (!tc) return;
-	const fromExtra = (tc.extra_content?.google)?.thought_signature;
-	if (typeof fromExtra === "string" && fromExtra.length > 0) return fromExtra;
-	const fromFunction = tc.function?.thought_signature;
-	return typeof fromFunction === "string" && fromFunction.length > 0 ? fromFunction : void 0;
-}
-function isGoogleOpenAICompatModel(model) {
-	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
-	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
-}
-function requiresGoogleCompatToolCallThoughtSignature(model) {
-	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
-}
-const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
-const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
-function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
-	return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
-}
-function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
-	if (!isGoogleOpenAICompatModel(model)) return;
-	const sigById = /* @__PURE__ */ new Map();
-	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
-	for (const msg of context.messages ?? []) {
-		if (msg.role !== "assistant") continue;
-		const source = msg;
-		if (!Array.isArray(source.content)) continue;
-		for (const block of source.content) {
-			if (block.type !== "toolCall") continue;
-			const id = block.id;
-			const sig = block.thoughtSignature;
-			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
-				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
-				if (!isSameRoute && !fallbackSig) continue;
-				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
-			}
+		if (choice.finish_reason) {
+			const finishReasonResult = mapOpenAIStopReason(choice.finish_reason, { allowSingularToolCall: true });
+			output.stopReason = finishReasonResult.stopReason;
+			if (finishReasonResult.stopReason === "stop") sawStopFinishReason = true;
+			if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
 		}
-	}
-	if (sigById.size === 0 && !fallbackSig) return;
-	for (const message of outgoingMessages) {
-		const toolCalls = message.tool_calls;
-		if (!Array.isArray(toolCalls)) continue;
-		for (const toolCall of toolCalls) {
-			const id = toolCall.id;
-			if (typeof id !== "string") continue;
-			let sig = sigById.get(id) ?? fallbackSig;
-			if (typeof sig === "string" && sig.length > 0) {
-				if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
+		const rawChoiceDelta = choice.delta ?? choice.message;
+		if (!rawChoiceDelta) {
+			emitReasoningUsageActivity(hasReasoningUsageActivity);
+			await cooperativeScheduler.afterEvent();
+			continue;
+		}
+		for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
+			const choiceDelta = normalizedDelta.delta;
+			const reasoningBatch = readOpenAICompletionsReasoningBatch(choiceDelta, visibleReasoningDetailTypes);
+			const reasoningDeltas = reasoningBatch.deltas;
+			const hasReasoningThinking = reasoningBatch.hasThinking;
+			const contentDeltas = readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, reasoningBatch.mirroredThinking);
+			const lastVisibleTextIndex = contentDeltas.findLastIndex((delta) => delta.kind === "text");
+			const hasSameChunkVisibleText = reasoningBatch.hasVisibleText || lastVisibleTextIndex !== -1;
+			if (hasReasoningThinking) {
+				beginReasoning(hasSameChunkVisibleText, true);
+				appendReasoningDeltas(reasoningDeltas);
+			}
+			for (const [contentDeltaIndex, contentDelta] of contentDeltas.entries()) if (contentDelta.kind === "text") {
+				const routedDeltas = hasReasoningThinking ? reasoningTagTextPartitioner.push(contentDelta.text) : reasoningTagTextPartitioner.pushVisible(contentDelta.text);
+				for (const routedDelta of routedDeltas) appendPartitionedVisibleDelta(routedDelta);
+			} else {
+				beginReasoning(contentDeltaIndex < lastVisibleTextIndex);
+				appendRoutedContentDelta(contentDelta);
+			}
+			if (!hasReasoningThinking) appendReasoningDeltas(reasoningDeltas);
+			const toolCallDeltas = normalizedDelta.toolCalls;
+			if (toolCallDeltas.length > 0) {
+				sawNativeToolCallDelta = true;
+				flushReasoningTagTextPartitioner();
+				rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
+				for (const toolCall of toolCallDeltas) {
+					const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
+					let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
+					if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
+					if (!block) {
+						if (currentBlock?.type === "toolCall") {
+							currentBlock = null;
+							flushPendingPostToolCallDeltas();
+						}
+						const initialSig = extractToolCallThoughtSignature(toolCall);
+						block = {
+							type: "toolCall",
+							id: toolCall.id || "",
+							name: toolCall.function?.name || "",
+							arguments: {},
+							partialArgs: "",
+							...initialSig ? { thoughtSignature: initialSig } : {}
+						};
+						output.content.push(block);
+						toolCallBlockIndices.set(block, output.content.length - 1);
+						pushStreamEvent({
+							type: "toolcall_start",
+							contentIndex: toolCallBlockIndices.get(block) ?? -1,
+							partial: output
+						});
+					}
+					if (streamIndex !== void 0 && !toolCallBlocksByIndex.has(streamIndex)) toolCallBlocksByIndex.set(streamIndex, block);
+					if (toolCall.id) {
+						block.id = toolCall.id;
+						toolCallBlocksById.set(toolCall.id, block);
+					}
+					currentBlock = block;
+					if (toolCall.function?.name) block.name = toolCall.function.name;
+					const deltaSig = extractToolCallThoughtSignature(toolCall);
+					if (deltaSig) block.thoughtSignature = deltaSig;
+					if (toolCall.function?.arguments) {
+						block.partialArgs += toolCall.function.arguments;
+						block.arguments = parseStreamingJson(block.partialArgs);
+						pushStreamEvent({
+							type: "toolcall_delta",
+							contentIndex: toolCallBlockIndices.get(block) ?? -1,
+							delta: toolCall.function.arguments,
+							partial: output
+						});
+					}
+				}
 			}
-			if (typeof sig !== "string" || sig.length === 0) continue;
-			const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
-			toolCall.extra_content = extra;
-			const google = extra.google && typeof extra.google === "object" ? extra.google : {};
-			extra.google = google;
-			google.thought_signature = sig;
 		}
+		flushPendingPostToolCallDeltas();
+		emitReasoningUsageActivity(hasReasoningUsageActivity);
+		await cooperativeScheduler.afterEvent();
 	}
+	flushReasoningTagTextPartitioner();
+	flushDeepSeekToolCallRecovererAtEnd();
+	flushDeepSeekTextFilterAtEnd();
+	currentBlock = null;
+	flushPendingPostToolCallDeltas();
+	finalizeOpenAICompletionsToolCalls(output, {
+		allowSilentToolCallPromotion: sawStopFinishReason || sawNativeToolCallDelta && (options?.sawStreamDONE?.() ?? false),
+		onConfirmedToolCall(block, contentIndex) {
+			if (block.type !== "toolCall") return;
+			pushStreamEvent({
+				type: "toolcall_end",
+				contentIndex,
+				toolCall: block,
+				partial: output
+			});
+		}
+	});
+	if (confirmedInterruptedTextBlock && output.stopReason !== "toolUse" && output.stopReason !== "error" && output.stopReason !== "aborted") tagInterruptedTextPhases(output.content, confirmedInterruptedTextBlock, explicitVisibleTextBlocks);
+	if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
+	if (output.stopReason === "error" || output.stopReason === "aborted") tagUnresolvedTextAsCommentary(output);
+	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 }
-const COMPLETIONS_REASONING_REPLAY_FIELDS = [
-	"reasoning_details",
-	"reasoning_content",
-	"reasoning",
-	"reasoning_text"
-];
-function stripCompletionsReasoningReplayFields(record) {
-	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
-}
-function sanitizeOpenRouterReasoningReplayFields(record) {
-	const reasoningDetails = record.reasoning_details;
-	if (typeof reasoningDetails === "string") {
-		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
-		delete record.reasoning_details;
-	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
-	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
-	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
-	const reasoningText = record.reasoning_text;
-	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
-	if ("reasoning_text" in record) delete record.reasoning_text;
-}
-function sanitizeReasoningContentReplayFields(record) {
-	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
-	delete record.reasoning_details;
-	delete record.reasoning;
-	delete record.reasoning_text;
-}
-const REASONING_CONTENT_REPLAY_MODEL_IDS = /* @__PURE__ */ new Set([
-	"deepseek-v4-flash",
-	"deepseek-v4-pro",
-	"kimi-for-coding",
-	"kimi-k2.5",
-	"kimi-k2.6",
-	"kimi-k2.7-code",
-	"kimi-k2.7-code-highspeed",
-	"kimi-k3",
-	"kimi-k2-thinking",
-	"kimi-k2-thinking-turbo",
-	"mimo-v2-pro",
-	"mimo-v2-omni",
-	"mimo-v2.5",
-	"mimo-v2.5-pro",
-	"mimo-v2.6-pro"
-]);
-const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
-	"-free",
-	"-paid",
-	"-trial"
-];
-function stripReasoningContentReplayTierSuffix(modelId) {
-	for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
-	return modelId;
-}
-function getReasoningContentReplayModelIdCandidates(modelId) {
-	if (typeof modelId !== "string") return [];
-	const normalized = modelId.trim().toLowerCase();
-	if (!normalized) return [];
-	const parts = normalized.split("/").filter(Boolean);
-	const finalPart = parts[parts.length - 1] ?? normalized;
-	const candidates = [finalPart];
-	const colonParts = finalPart.split(":").filter(Boolean);
-	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
-	const baseCount = candidates.length;
-	for (let index = 0; index < baseCount; index += 1) {
-		const candidate = candidates[index];
-		if (typeof candidate !== "string") continue;
-		const stripped = stripReasoningContentReplayTierSuffix(candidate);
-		if (stripped !== candidate) candidates.push(stripped);
-	}
-	return uniqueStrings(candidates.filter(Boolean));
-}
-function shouldPreserveReasoningContentReplay(model, compat) {
-	if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
-	return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
-}
-function shouldPreserveOpenRouterReasoningReplay(model) {
-	if (model.provider !== "openrouter") return true;
-	const normalizedModelId = model.id.trim().toLowerCase();
-	return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
+function resolveOpenAICompletionsReasoningEffort(options) {
+	return options?.reasoningEffort ?? options?.reasoning ?? "high";
 }
-function shouldTrustReasoningContentReplayMetadata(model) {
+function shouldEmitOpenAICompletionsReasoning(model, options) {
 	if (!model.reasoning) return false;
-	if (model.provider.trim().toLowerCase() === "openai") return false;
-	return shouldPreserveOpenRouterReasoningReplay(model);
+	const effort = resolveOpenAICompletionsReasoningEffort(options);
+	if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
+	return true;
 }
-function sanitizeCompletionsReasoningReplayFields(messages, options) {
-	if (!Array.isArray(messages)) return;
-	for (const msg of messages) {
-		if (!msg || typeof msg !== "object") continue;
-		const record = msg;
-		if (record.role !== "assistant") continue;
-		if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
-		else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
-		else stripCompletionsReasoningReplayFields(record);
-	}
+function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
+	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
+	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
 }
-function buildOpenAICompletionsParams(model, context, options) {
-	const compat = getCompat(model);
-	const compatDetection = detectOpenAICompletionsCompat(model);
-	let messages = convertMessages(model, context.systemPrompt ? {
-		...context,
-		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
-	} : context, compat);
-	injectToolCallThoughtSignatures(messages, context, model);
-	sanitizeCompletionsReasoningReplayFields(messages, {
-		preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
-		preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
-	});
-	if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
-	const params = {
-		model: model.id,
-		messages: compat.requiresStringContent ? flattenCompletionMessagesToStringContent(messages) : messages,
-		stream: true
+//#endregion
+//#region packages/ai/src/transports/openai-completions-transport.ts
+function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
+	const messages = params.messages;
+	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
+	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
+}
+const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
+const SSE_DONE_MAX_LINE_CHARS = 1024;
+function createSseDoneDetector() {
+	const decoder = new TextDecoder();
+	let line = "";
+	let lineOverflowed = false;
+	let sawDone = false;
+	const finishLine = () => {
+		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
+		line = "";
+		lineOverflowed = false;
 	};
-	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
-	if (compat.supportsStore) params.store = false;
-	if (compat.supportsPromptCacheKey && promptCacheKey) {
-		params.prompt_cache_key = promptCacheKey;
-		if (cacheRetention === "long" && compat.supportsLongCacheRetention) params.prompt_cache_retention = "24h";
-	}
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (options?.topP !== void 0) params.top_p = options.topP;
-	const responseFormat = resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
-		provider: model.provider,
-		baseUrl: model.baseUrl,
-		hasTools: () => Boolean(context.tools?.length)
-	}) ? void 0 : options?.responseFormat, compat.supportsJsonSchemaResponseFormat);
-	if (responseFormat !== void 0) params.response_format = responseFormat;
-	if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
-	if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
-	if (options?.seed !== void 0) params.seed = options.seed;
-	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
-	if (supportsModelTools(model)) {
-		if (context.tools) {
-			const converted = convertTools(context.tools, compat, model);
-			if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
-			else if (hasToolHistory(context.messages)) params.tools = [];
-			if (options?.toolChoice) {
-				const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, converted.projection);
-				if (toolChoice !== void 0) params.tool_choice = toolChoice;
-			} else if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
-		} else if (hasToolHistory(context.messages)) params.tools = [];
-		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
-			delete params.tools;
-			delete params.tool_choice;
+	const observeText = (text) => {
+		for (const char of text) {
+			if (char === "\n" || char === "\r") {
+				finishLine();
+				continue;
+			}
+			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
+			else lineOverflowed = true;
 		}
-	}
-	{
-		const maxTokenBudget = resolveOpenAICompletionsMaxTokens(model, options);
-		const effectiveMaxTokens = maxTokenBudget.maxTokens;
-		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
-		let clampedMaxTokens = effectiveMaxTokens;
-		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
-		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
-			clampedMaxTokens = modelMaxTokens;
-			emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
+	};
+	return {
+		observe(chunk) {
+			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
+		},
+		finish() {
+			if (sawDone) return;
+			observeText(decoder.decode());
+			if (line || lineOverflowed) finishLine();
+		},
+		sawDone: () => sawDone
+	};
+}
+function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, opts) {
+	const clientConfig = buildOpenAICompletionsClientConfig(model, context, optionHeaders);
+	return new OpenAI({
+		apiKey,
+		baseURL: clientConfig.baseURL,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: clientConfig.defaultHeaders,
+		defaultQuery: clientConfig.defaultQuery,
+		fetch: opts?.fetch ?? buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	});
+}
+function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
+	const headers = buildOpenAIClientHeaders(model, context, optionHeaders);
+	const defaultQuery = {};
+	let baseURL = model.baseUrl;
+	let isAzureHost = false;
+	try {
+		const parsed = new URL(model.baseUrl);
+		isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
+		parsed.searchParams.forEach((value, key) => {
+			if (value) defaultQuery[key] = value;
+		});
+		parsed.search = "";
+		baseURL = parsed.toString().replace(/\/$/, "");
+	} catch {}
+	if (isAzureHost) {
+		const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
+		if (apiVersionHeader) {
+			const apiVersion = headers[apiVersionHeader]?.trim();
+			delete headers[apiVersionHeader];
+			if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
 		}
-		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
-			const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
-			const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
-			if (clampedMaxTokens > remainingBudget) {
-				clampedMaxTokens = remainingBudget;
-				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
+	}
+	return {
+		baseURL,
+		defaultHeaders: headers,
+		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
+	};
+}
+function createOpenAICompletionsTransportStreamFn() {
+	return (model, context, options) => {
+		const { eventStream, stream } = createWritableTransportEventStream();
+		(async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			let firstEventAbort;
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const doneDetector = createSseDoneDetector();
+				const baseFetch = buildGuardedModelFetch(model);
+				const doneDetectingFetch = async (url, init) => {
+					const response = await baseFetch(url, init);
+					if (!response.body || !response.ok) return response;
+					if (typeof TransformStream === "undefined" || !response.body.pipeThrough) return response;
+					const transformed = response.body.pipeThrough(new TransformStream({
+						transform(chunk, controller) {
+							doneDetector.observe(chunk);
+							controller.enqueue(chunk);
+						},
+						flush() {
+							doneDetector.finish();
+						}
+					}));
+					return new Response(transformed, {
+						headers: response.headers,
+						status: response.status,
+						statusText: response.statusText
+					});
+				};
+				const client = createOpenAICompletionsClient(model, context, apiKey, options?.headers, { fetch: doneDetectingFetch });
+				let params = buildOpenAICompletionsParams(model, context, options);
+				const nextParams = await options?.onPayload?.(params, model);
+				if (nextParams !== void 0) params = nextParams;
+				if (options?.openclawCodeModeToolSurface === true) {
+					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
+					enforceCodeModeResponsesToolSurface(params, visibleToolNames, void 0, codeModeToolSurfaceObserver.get(options));
+					assertCodeModeResponsesToolSurface(params, visibleToolNames);
+				}
+				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({
+					stream: responseStream,
+					signal: firstEventAbort.signal,
+					abort: firstEventAbort.abort,
+					hook: createOpenAIProviderAcceptanceHook(options, response, model),
+					onReady: () => stream.push({
+						type: "start",
+						partial: output
+					})
+				}), output, model, stream, {
+					signal: options?.signal,
+					emitReasoning,
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+					sawStreamDONE: doneDetector.sawDone
+				});
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: options?.signal
+				});
+			} catch (error) {
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error,
+					cleanup: () => {
+						output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+						finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
+						tagUnresolvedTextAsCommentary(output);
+					}
+				});
+			} finally {
+				firstEventAbort?.dispose();
 			}
-		}
-		if (clampedMaxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
-		else params.max_completion_tokens = clampedMaxTokens;
-	}
-	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
-	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
-		model,
-		effort: completionsReasoningEffort,
-		fallbackMap: compat.reasoningEffortMap
-	}) : void 0;
-	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
-	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
-	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	applyTogetherOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
-	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
-	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
-	return params;
-}
-function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
-	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
+		})();
+		return eventStream;
+	};
 }
-const completionsTesting = {
-	getCompat,
-	createSseDoneDetector,
-	createOpenAICompletionsClient,
-	buildOpenAICompletionsClientConfig,
-	parseTransportChunkUsage: parseOpenAICompletionsUsage,
-	processOpenAICompletionsStream,
-	shouldEmitOpenAICompletionsReasoningForModel
-};
-if (process.env.VITEST || false) globalThis.openclawOpenAICompletionsTransportTestApi = completionsTesting;
 //#endregion
-//#region packages/ai/src/transports/openai-responses-payload-policy.ts
-/**
-* OpenAI Responses payload policy.
-* Classifies endpoint capabilities and applies store, prompt-cache,
-* server-compaction, service-tier, and reasoning payload rules.
-*/
-const OPENAI_RESPONSES_APIS = /* @__PURE__ */ new Set([
-	"openai-responses",
-	"azure-openai-responses",
-	"openai-chatgpt-responses",
-	"openclaw-openai-responses-transport",
-	"openclaw-openai-chatgpt-responses-transport"
-]);
-const OPENAI_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set([
-	"openai",
-	"azure-openai",
-	"azure-openai-responses"
-]);
-const LOCAL_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
-	"localhost",
-	"127.0.0.1",
-	"::1",
-	"[::1]"
-]);
-const MODELSTUDIO_NATIVE_BASE_URLS = /* @__PURE__ */ new Set([
-	"https://coding-intl.dashscope.aliyuncs.com/v1",
-	"https://coding.dashscope.aliyuncs.com/v1",
-	"https://dashscope.aliyuncs.com/compatible-mode/v1",
-	"https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-]);
-const MOONSHOT_NATIVE_BASE_URLS = /* @__PURE__ */ new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
-function normalizeLowercaseString(value) {
-	const stringValue = readStringValue(value)?.trim().toLowerCase();
-	return stringValue ? stringValue : void 0;
-}
-function normalizeComparableBaseUrl(value) {
-	const trimmed = readStringValue(value)?.trim();
-	if (!trimmed) return;
-	const parsedValue = /^[a-z0-9.[\]-]+(?::\d+)?(?:[/?#].*)?$/i.test(trimmed) ? `https://${trimmed}` : trimmed;
-	try {
-		const url = new URL(parsedValue);
-		if (url.protocol !== "http:" && url.protocol !== "https:") return;
-		url.hash = "";
-		url.search = "";
-		return url.toString().replace(/\/+$/, "").toLowerCase();
-	} catch {
-		return;
+//#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;
 	}
 }
-function resolveUrlHostname(value) {
-	const trimmed = readStringValue(value)?.trim();
-	if (!trimmed) return;
+/** 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 new URL(trimmed).hostname.toLowerCase();
-	} catch {
-		try {
-			return new URL(`https://${trimmed}`).hostname.toLowerCase();
-		} catch {
-			return;
-		}
+		return await result;
+	} finally {
+		await stream.result().catch(() => void 0);
 	}
 }
-function hostMatchesSuffix(host, suffix) {
-	return suffix.startsWith(".") || suffix.startsWith("-") ? host.endsWith(suffix) : host === suffix || host.endsWith(`.${suffix}`);
-}
-function isLocalEndpointHost(host) {
-	return LOCAL_ENDPOINT_HOSTS.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
-}
-function resolveBundledOpenAIResponsesEndpointClass(baseUrl) {
-	const trimmed = readStringValue(baseUrl)?.trim();
-	if (!trimmed) return "default";
-	const host = resolveUrlHostname(trimmed);
-	if (!host) return "invalid";
-	const comparableBaseUrl = normalizeComparableBaseUrl(trimmed);
-	switch (host) {
-		case "api.anthropic.com": return "anthropic-public";
-		case "api.cerebras.ai": return "cerebras-native";
-		case "llm.chutes.ai": return "chutes-native";
-		case "api.deepseek.com": return "deepseek-native";
-		case "api.groq.com": return "groq-native";
-		case "api.mistral.ai": return "mistral-public";
-		case "api.openai.com": return "openai-public";
-		case "chatgpt.com": return "openai";
-		case "generativelanguage.googleapis.com": return "google-generative-ai";
-		case "aiplatform.googleapis.com": return "google-vertex";
-		case "api.x.ai": return "xai-native";
-		case "api.z.ai": return "zai-native";
-	}
-	if (hostMatchesSuffix(host, ".githubcopilot.com")) return "github-copilot-native";
-	if (hostMatchesSuffix(host, ".openai.azure.com")) return "azure-openai";
-	if (hostMatchesSuffix(host, "openrouter.ai")) return "openrouter";
-	if (hostMatchesSuffix(host, "opencode.ai")) return "opencode-native";
-	if (hostMatchesSuffix(host, "-aiplatform.googleapis.com")) return "google-vertex";
-	if (comparableBaseUrl && MOONSHOT_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "moonshot-native";
-	if (comparableBaseUrl && MODELSTUDIO_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "modelstudio-native";
-	if (isLocalEndpointHost(host)) return "local";
-	return "custom";
-}
-function isOpenAIResponsesApi(api) {
-	return api !== void 0 && OPENAI_RESPONSES_APIS.has(api);
-}
-function readCompatPayloadBoolean(compat, key) {
-	if (!compat || typeof compat !== "object") return;
-	const value = compat[key];
-	return typeof value === "boolean" ? value : void 0;
-}
-function resolveOpenAIResponsesPayloadCapabilities(model) {
-	const provider = normalizeLowercaseString(model.provider);
-	const api = normalizeLowercaseString(model.api);
-	const isOpenAIProvider = provider === "openai";
-	const endpointClass = resolveBundledOpenAIResponsesEndpointClass(model.baseUrl);
-	const isResponsesApi = isOpenAIResponsesApi(api);
-	const usesConfiguredBaseUrl = endpointClass !== "default";
-	const usesKnownNativeOpenAIEndpoint = endpointClass === "openai-public" || endpointClass === "openai" || endpointClass === "azure-openai";
-	const usesKnownNativeOpenAIRoute = endpointClass === "default" ? provider === "openai" : usesKnownNativeOpenAIEndpoint;
-	const usesExplicitProxyLikeEndpoint = usesConfiguredBaseUrl && !usesKnownNativeOpenAIEndpoint;
-	const promptCacheKeySupport = readCompatPayloadBoolean(model.compat, "supportsPromptCacheKey");
-	const shouldStripResponsesPromptCache = promptCacheKeySupport === true ? false : promptCacheKeySupport === false ? isResponsesApi : isResponsesApi && usesExplicitProxyLikeEndpoint;
-	const supportsResponsesStoreField = readCompatPayloadBoolean(model.compat, "supportsStore") !== false && isResponsesApi;
+//#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 {
-		allowsOpenAIServiceTier: provider === "openai" && (api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai-public" || isOpenAIProvider && (api === "openai-chatgpt-responses" || api === "openclaw-openai-chatgpt-responses-transport" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
-		allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && api !== "openclaw-openai-chatgpt-responses-transport" && provider !== void 0 && OPENAI_RESPONSES_PROVIDERS.has(provider) && usesKnownNativeOpenAIEndpoint,
-		shouldStripResponsesPromptCache,
-		supportsResponsesStoreField,
-		usesKnownNativeOpenAIRoute
-	};
-}
-function parsePositiveInteger(value) {
-	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
-	if (typeof value === "string") return parseStrictPositiveInteger(value);
-}
-function resolveOpenAIResponsesCompactThreshold(model) {
-	const contextWindow = parsePositiveInteger(model.contextWindow);
-	if (contextWindow) return Math.max(1e3, Math.floor(contextWindow * .7));
-	return 8e4;
-}
-function shouldEnableOpenAIResponsesServerCompaction(explicitStore, provider, extraParams) {
-	const configured = extraParams?.responsesServerCompaction;
-	if (configured === false) return false;
-	if (explicitStore !== true) return false;
-	if (configured === true) return true;
-	return provider === "openai";
-}
-function stripDisabledOpenAIReasoningPayload(payloadObj) {
-	const reasoning = payloadObj.reasoning;
-	if (reasoning === "none") {
-		delete payloadObj.reasoning;
-		return;
-	}
-	if (!reasoning || typeof reasoning !== "object" || Array.isArray(reasoning)) return;
-	if (reasoning.effort === "none") delete payloadObj.reasoning;
-}
-/** Strip returned-item metadata rejected by strict Responses-compatible endpoints. */
-function stripInputItemStatuses(input) {
-	if (!Array.isArray(input)) return;
-	for (const item of input) if (item && typeof item === "object" && !Array.isArray(item)) delete item.status;
-}
-/** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */
-function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
-	const capabilities = resolveOpenAIResponsesPayloadCapabilities(model);
-	const storeMode = options.storeMode ?? "provider-policy";
-	const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore ? true : void 0;
-	const isResponsesApi = isOpenAIResponsesApi(normalizeLowercaseString(model.api));
-	const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
-	const shouldStripInputStatus = isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute;
+		...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 {
-		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
-		compactThreshold: parsePositiveInteger(options.extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model),
-		explicitStore,
-		shouldStripDisabledReasoningPayload,
-		shouldStripInputStatus,
-		shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
-		shouldStripStore: explicitStore !== true && readCompatPayloadBoolean(model.compat, "supportsStore") === false && isResponsesApi,
-		useServerCompaction: options.enableServerCompaction === true && shouldEnableOpenAIResponsesServerCompaction(explicitStore, model.provider, options.extraParams)
-	};
-}
-/** Mutate a Responses request payload according to the resolved endpoint policy. */
-function applyOpenAIResponsesPayloadPolicy(payloadObj, policy) {
-	if (policy.explicitStore !== void 0) payloadObj.store = policy.explicitStore;
-	if (policy.shouldStripStore) delete payloadObj.store;
-	if (policy.shouldStripPromptCache) {
-		delete payloadObj.prompt_cache_key;
-		delete payloadObj.prompt_cache_retention;
-	}
-	if (policy.useServerCompaction && payloadObj.context_management === void 0) payloadObj.context_management = [{
-		type: "compaction",
-		compact_threshold: policy.compactThreshold
-	}];
-	if (policy.shouldStripDisabledReasoningPayload) stripDisabledOpenAIReasoningPayload(payloadObj);
-	if (policy.shouldStripInputStatus) stripInputItemStatuses(payloadObj.input);
+		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",
+	"opencode",
+	"azure-openai-responses",
+	"github-copilot"
+]);
 function convertResponsesTools(tools, model, options) {
 	const projection = projectOpenAITools(tools);
 	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, options?.strict, {
@@ -3114,7 +3135,7 @@ function resolveOpenAIResponsesTextFormat(responseFormat) {
 	};
 	return responseFormat;
 }
-function buildOpenAIResponsesParams(model, context, options, metadata) {
+function convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode) {
 	const isCodexResponses = isOpenAICodexResponsesModel(model);
 	const isNativeCodexResponses = usesNativeOpenAICodexResponsesBackend(model);
 	const compat = getCompat(model);
@@ -3122,19 +3143,20 @@ function buildOpenAIResponsesParams(model, context, options, metadata) {
 	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
 	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
 	const replayResponsesItemIds = !isNativeCodexResponses && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
-	const messages = convertResponsesMessages(model, context, /* @__PURE__ */ new Set([
-		"openai",
-		"opencode",
-		"azure-openai-responses",
-		"github-copilot"
-	]), {
+	return convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
 		includeSystemPrompt: !isCodexResponses,
 		supportsDeveloperRole,
 		replayReasoningItems: true,
 		replayResponsesItemIds,
 		authProfileId: options?.authProfileId,
-		sessionId: options?.sessionId
+		sessionId: options?.sessionId,
+		replayMode
 	});
+}
+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);
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
@@ -3194,6 +3216,261 @@ function buildOpenAIResponsesParams(model, context, options, metadata) {
 	return sanitizeOpenAICodexResponsesParams(model, params);
 }
 //#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 WEBSOCKET_OPEN_STATE = 1;
+const websocketSessionCache = /* @__PURE__ */ new Map();
+const degradedWebSocketConnections = /* @__PURE__ */ new Map();
+function isOfficialOpenAIResponsesBaseUrl(baseUrl) {
+	if (!baseUrl) return false;
+	try {
+		const url = new URL(baseUrl);
+		return url.origin === "https://api.openai.com" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && url.pathname.replace(/\/+$/, "") === "/v1";
+	} catch {
+		return false;
+	}
+}
+function supportsNativeOpenAIResponsesEndpoint(params) {
+	return params.provider.trim().toLowerCase() === "openai" && params.api === "openai-responses" && isOfficialOpenAIResponsesBaseUrl(params.baseUrl);
+}
+function closeWebSocketSilently(socket, reason = "done") {
+	try {
+		socket.close({
+			code: 1e3,
+			reason
+		});
+	} catch {}
+}
+function invalidateOwnedWebSocketSession(cacheKey, entry, reason = "done") {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+		entry.idleTimer = void 0;
+	}
+	closeWebSocketSilently(entry.socket, reason);
+	if (websocketSessionCache.get(cacheKey) === entry) websocketSessionCache.delete(cacheKey);
+}
+function scheduleSessionWebSocketExpiry(cacheKey, entry) {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy) return;
+		invalidateOwnedWebSocketSession(cacheKey, entry, "idle_timeout");
+	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
+	entry.idleTimer.unref?.();
+}
+function prepareWebSocketConnection(client, headers) {
+	if (!isOfficialOpenAIResponsesBaseUrl(client.baseURL)) throw new Error("OpenAI Responses WebSocket requires the official API endpoint");
+	if (typeof client.apiKey !== "string" || client.apiKey.length === 0) throw new Error("OpenAI Responses WebSocket requires an API key");
+	const resolvedApiKey = getAiTransportHost().resolveSecretSentinel(client.apiKey);
+	const resolvedHeaders = { ...resolveAiTransportHeaderSentinels(headers) };
+	for (const key of Object.keys(resolvedHeaders)) {
+		const normalizedKey = key.toLowerCase();
+		if (normalizedKey === "authorization" || normalizedKey === "traceparent") delete resolvedHeaders[key];
+	}
+	if (!resolvedApiKey) throw new Error("OpenAI Responses WebSocket requires a resolved API key");
+	return {
+		client: client.withOptions({ apiKey: resolvedApiKey }),
+		headers: resolvedHeaders,
+		identity: sha256Hex(JSON.stringify([
+			resolvedApiKey,
+			client.baseURL,
+			Object.entries(resolvedHeaders).toSorted(([a], [b]) => a.localeCompare(b))
+		]))
+	};
+}
+function createWebSocket(connection, onError) {
+	const socket = new ResponsesWS(connection.client, {
+		headers: connection.headers,
+		maxQueueSize: 1
+	});
+	socket.on("error", () => onError(socket));
+	return socket;
+}
+function createTransientWebSocketLease(connection) {
+	const socket = createWebSocket(connection, (failedSocket) => closeWebSocketSilently(failedSocket, "transport_error"));
+	return {
+		socket,
+		iterator: socket.stream(),
+		reusedConnection: false,
+		release: () => closeWebSocketSilently(socket)
+	};
+}
+function createCachedWebSocketLease(cacheKey, entry, reusedConnection) {
+	entry.busy = true;
+	return {
+		socket: entry.socket,
+		iterator: entry.socket.stream(),
+		entry,
+		reusedConnection,
+		release: ({ keep } = {}) => {
+			if (!keep || entry.socket.socket.readyState !== WEBSOCKET_OPEN_STATE) {
+				invalidateOwnedWebSocketSession(cacheKey, entry);
+				return;
+			}
+			entry.busy = false;
+			scheduleSessionWebSocketExpiry(cacheKey, entry);
+		}
+	};
+}
+function acquireWebSocket(params, connection) {
+	if (!(params.mode !== "websocket" && Boolean(params.sessionId)) || !params.sessionId) return createTransientWebSocketLease(connection);
+	const cacheKey = `${params.sessionId}\0${connection.identity}`;
+	const cached = websocketSessionCache.get(cacheKey);
+	if (cached) {
+		if (cached.idleTimer) {
+			clearTimeout(cached.idleTimer);
+			cached.idleTimer = void 0;
+		}
+		if (cached.busy) return createTransientWebSocketLease(connection);
+		const expired = Date.now() - cached.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+		if (!expired && cached.socket.socket.readyState === WEBSOCKET_OPEN_STATE) return createCachedWebSocketLease(cacheKey, cached, true);
+		invalidateOwnedWebSocketSession(cacheKey, cached, expired ? "connection_age_limit" : "done");
+	}
+	const entry = {
+		socket: createWebSocket(connection, (failedSocket) => {
+			const failedEntry = websocketSessionCache.get(cacheKey);
+			if (failedEntry?.socket === failedSocket) invalidateOwnedWebSocketSession(cacheKey, failedEntry, "transport_error");
+			else closeWebSocketSilently(failedSocket, "transport_error");
+		}),
+		sessionId: params.sessionId,
+		busy: true,
+		createdAt: Date.now()
+	};
+	websocketSessionCache.set(cacheKey, entry);
+	return createCachedWebSocketLease(cacheKey, entry, false);
+}
+function sanitizeWebSocketRequest(request) {
+	const { stream: _stream, background: _background, ...websocketRequest } = request;
+	return websocketRequest;
+}
+async function nextWebSocketMessage(iterator, signal) {
+	if (!signal) return iterator.next();
+	if (signal.aborted) throw transportAbortError(signal);
+	let onAbort;
+	try {
+		return await Promise.race([iterator.next(), new Promise((_resolve, reject) => {
+			onAbort = () => reject(transportAbortError(signal));
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+function readServerEvent(message) {
+	if (message.type === "message") return message.message;
+	if (message.type === "error") throw parseOpenAIResponsesWebSocketServerError(message.error) ?? new Error("OpenAI Responses WebSocket transport failed", { cause: message.error });
+	if (message.type === "close") throw new Error(`OpenAI Responses WebSocket closed before completion (code ${message.code})`);
+}
+function createOpenAIResponsesWebSocketStream(params) {
+	const connection = prepareWebSocketConnection(params.client, params.headers);
+	const fullRequest = sanitizeWebSocketRequest(params.request);
+	const requestModel = typeof fullRequest.model === "string" ? fullRequest.model : "";
+	const degradationKey = `${params.sessionId ?? ""}\0${connection.identity}\0${requestModel}`;
+	const degraded = degradedWebSocketConnections.get(degradationKey);
+	if (degraded && degraded.retryAt > Date.now()) throw new OpenAIResponsesWebSocketPreDispatchError(/* @__PURE__ */ new Error("OpenAI Responses WebSocket is cooling down after a transport failure"));
+	degradedWebSocketConnections.delete(degradationKey);
+	const markDegraded = () => {
+		const cooldownMs = params.degradeCooldownMs;
+		if (cooldownMs === void 0 || !Number.isFinite(cooldownMs) || cooldownMs <= 0) return;
+		degradedWebSocketConnections.set(degradationKey, {
+			sessionId: params.sessionId,
+			retryAt: Date.now() + cooldownMs
+		});
+	};
+	let lease;
+	try {
+		lease = acquireWebSocket(params, connection);
+	} catch (error) {
+		markDegraded();
+		throw new OpenAIResponsesWebSocketPreDispatchError(error);
+	}
+	let prepared;
+	try {
+		const continuation = lease.entry?.continuation;
+		if (continuation && lease.entry) {
+			lease.entry.continuation = void 0;
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest);
+		} else prepared = {
+			request: fullRequest,
+			continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
+		};
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw error;
+	}
+	let streamStarted = false;
+	let terminalResponse;
+	let terminalReceived = false;
+	let released = false;
+	const finish = ({ keep = true } = {}) => {
+		if (released) return;
+		released = true;
+		if (keep && lease.entry && terminalResponse) lease.entry.continuation = {
+			lastRequest: fullRequest,
+			lastResponseId: terminalResponse.id,
+			lastResponseItems: terminalResponse.output
+		};
+		lease.release({ keep });
+	};
+	return {
+		stream: { async *[Symbol.asyncIterator]() {
+			if (streamStarted) throw new Error("OpenAI Responses WebSocket stream can only be consumed once");
+			streamStarted = true;
+			const iterator = lease.iterator;
+			let requestDispatched = false;
+			try {
+				if (params.signal?.aborted) throw transportAbortError(params.signal);
+				for (;;) {
+					const next = 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) {
+							requestDispatched = true;
+							lease.socket.send({
+								...prepared.request,
+								type: "response.create"
+							});
+						}
+						continue;
+					}
+					const event = readServerEvent(next.value);
+					if (!event) continue;
+					if (event.type === "response.completed") terminalResponse = event.response;
+					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
+					yield event;
+					if (terminalReceived) {
+						degradedWebSocketConnections.delete(degradationKey);
+						return;
+					}
+				}
+			} catch (error) {
+				if (lease.entry) lease.entry.continuation = void 0;
+				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError;
+				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);
+				if (!terminalReceived) finish({ keep: false });
+			}
+		} },
+		request: prepared.request,
+		reusedConnection: lease.reusedConnection,
+		continuationStatus: prepared.continuationStatus,
+		finish
+	};
+}
+function closeOpenAIResponsesWebSocketSessions(sessionId) {
+	for (const [cacheKey, entry] of websocketSessionCache) {
+		if (sessionId && entry.sessionId !== sessionId) continue;
+		invalidateOwnedWebSocketSession(cacheKey, entry, "session_cleanup");
+	}
+	for (const [key, entry] of degradedWebSocketConnections) if (!sessionId || entry.sessionId === sessionId) degradedWebSocketConnections.delete(key);
+}
+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:";
@@ -3338,6 +3615,20 @@ function sanitizeResponsesImagePayload(params) {
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-client.ts
+function resolveNativeOpenAIResponsesWebSocketMode(model, transport) {
+	if (transport !== "websocket" && transport !== "websocket-cached" && transport !== "auto") return;
+	if (getAiTransportHost().requiresManagedTransport(model)) return;
+	return supportsNativeOpenAIResponsesEndpoint({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl
+	}) ? transport : void 0;
+}
+function combineWebSocketTimeoutSignal(signal, model, timeoutMs) {
+	const resolvedTimeoutMs = timeoutMs !== void 0 && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : getAiTransportHost().resolveModelRequestTimeoutMs(model);
+	if (resolvedTimeoutMs === void 0 || !Number.isFinite(resolvedTimeoutMs)) return signal;
+	return AbortSignal.any([signal, AbortSignal.timeout(Math.max(1, resolvedTimeoutMs))]);
+}
 function resolveProviderTransportTurnState(model, params) {
 	const normalizedProvider = model.provider.trim().toLowerCase();
 	const allowRuntimePluginLoad = normalizedProvider === "openai" || normalizedProvider === "azure-openai" || normalizedProvider === "azure-openai-responses";
@@ -3366,111 +3657,265 @@ function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turn
 		...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;
-		const eventStream = createAssistantMessageEventStream();
-		const stream = eventStream;
+		const compactRequest = claimResponsesCompactRequest(responsesOptions);
+		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
-			const output = {
-				role: "assistant",
-				content: [],
-				api: config.outputApi ?? model.api,
-				provider: model.provider,
-				model: model.id,
-				usage: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					totalTokens: 0,
-					cost: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						total: 0
-					}
-				},
-				stopReason: "stop",
-				timestamp: Date.now()
-			};
+			const output = createOpenAIResponsesAssistantOutput(model, config.outputApi);
 			let firstEventAbort;
+			let continuationClaim;
 			try {
 				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const websocketMode = resolveNativeOpenAIResponsesWebSocketMode(model, responsesOptions?.transport);
 				const turnState = resolveProviderTransportTurnState(model, {
 					sessionId: options?.sessionId,
 					turnId: randomUUID(),
 					attempt: 1,
-					transport: "stream"
+					transport: websocketMode ? "websocket" : "stream"
 				});
+				const websocketSessionPolicy = websocketMode ? turnState?.websocket : void 0;
+				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketSessionPolicy?.headers, options?.sessionId) : void 0;
 				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId);
-				let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata);
-				const nextParams = await options?.onPayload?.(params, model);
-				if (nextParams !== void 0) params = nextParams;
-				if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
-				params = sanitizeOpenAICodexResponsesParams(model, params);
-				params = sanitizeResponsesImagePayload(params);
-				if (options?.openclawCodeModeToolSurface === true) {
-					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
-					enforceCodeModeResponsesToolSurface(params, visibleToolNames);
-					assertCodeModeResponsesToolSurface(params, visibleToolNames);
+				const buildRequest = async (replayMode) => {
+					let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata, replayMode);
+					const nextParams = await options?.onPayload?.(params, model);
+					if (nextParams !== void 0) params = nextParams;
+					if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
+					params = sanitizeOpenAICodexResponsesParams(model, params);
+					params = sanitizeResponsesImagePayload(params);
+					if (options?.openclawCodeModeToolSurface === true) {
+						const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
+						const allowedHostedToolTypes = responsesOptions?.openclawCodeModeAllowedHostedToolTypes;
+						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
+						assertCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
+					}
+					return params;
+				};
+				const params = await buildRequest("checkpoint");
+				if (compactRequest) {
+					const compacted = await postOpenAIResponsesCompaction({
+						client,
+						model,
+						request: params,
+						options: responsesOptions
+					});
+					output.usage.input = compacted.usage.input_tokens;
+					output.usage.output = compacted.usage.output_tokens;
+					output.usage.totalTokens = compacted.usage.input_tokens + compacted.usage.output_tokens;
+					compactRequest.resolve(compacted);
+					finalizeTransportStream({
+						stream,
+						output,
+						signal: options?.signal
+					});
+					return;
 				}
+				const sessionId = options?.sessionId;
+				if (config.httpContinuation && !websocketMode && !getAiTransportHost().requiresManagedTransport(model) && supportsNativeOpenAIResponsesEndpoint({
+					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
+				});
 				const observePrompt = createResponsesPromptEgressObserver(responsesOptions, context.systemPrompt);
 				const requestStartedAt = Date.now();
-				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-				const requestOptions = buildOpenAISdkRequestOptions(model, firstEventAbort.signal, {
+				let started = false;
+				const startStream = () => {
+					if (!started) {
+						started = true;
+						stream.push({
+							type: "start",
+							partial: output
+						});
+					}
+				};
+				const firstEvent = createFirstStreamEventAbortController(options?.signal);
+				firstEventAbort = firstEvent;
+				const requestOptions = buildOpenAISdkRequestOptions(model, firstEvent.signal, {
 					stream: config.streamRequest,
 					timeoutMs: options?.timeoutMs,
 					maxRetries: options?.maxRetries
 				});
-				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
-				const { stream: responseStream, response } = await config.createResponseStream({
-					client,
-					request: params,
-					requestOptions,
-					model,
-					observePrompt
-				});
-				await options?.onResponse?.({
-					status: response.status,
-					headers: headersToRecord(response.headers)
-				}, model);
-				emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - requestStartedAt}`);
-				stream.push({
-					type: "start",
-					partial: output
-				});
-				await processResponsesStream(observeResponsesStream(responseStream, model), output, stream, model, {
-					...config.pricingOptions?.(responsesOptions),
-					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
-					abortFirstEventStream: firstEventAbort.abort,
-					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-					signal: options?.signal,
-					reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
-						authProfileId: responsesOptions?.authProfileId,
-						sessionId: options?.sessionId
-					})
-				});
-				if (options?.signal?.aborted) throw transportAbortError(options.signal);
-				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
-				stream.push({
-					type: "done",
-					reason: output.stopReason,
-					message: output
+				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: rawResponseStream, response, attempt } = await config.createResponseStream({
+						client,
+						request: initialRequest,
+						requestOptions,
+						model,
+						observePrompt,
+						initialAttemptKind,
+						initialRejectedCompaction,
+						buildFullHistoryRequest: () => buildRequest("full-history"),
+						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint)
+					});
+					if (continuationClaim) continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
+					return withProviderResponseHook({
+						stream: observeResponsesStream(rawResponseStream, model, requestStartedAt),
+						signal: firstEvent.signal,
+						abort: firstEvent.abort,
+						hook: createOpenAIProviderAcceptanceHook(options, response, model),
+						onReady: () => {
+							emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} transport=sse elapsedMs=${Date.now() - requestStartedAt}`);
+							startStream();
+						}
+					});
+				};
+				let responseStream;
+				let finishWebSocket;
+				let transport = "sse";
+				const logWebSocketFallback = (reason) => emitModelTransportDebug(log, `[responses] websocket_fallback provider=${model.provider} api=${model.api} model=${model.id} reason=${reason}`);
+				const closeWebSocketForFallback = (reason) => {
+					finishWebSocket?.({ keep: false });
+					finishWebSocket = void 0;
+					transport = "sse";
+					logWebSocketFallback(reason);
+				};
+				if (websocketMode) try {
+					const websocket = createOpenAIResponsesWebSocketStream({
+						client,
+						request: params,
+						mode: websocketMode,
+						sessionId: options?.sessionId,
+						headers: websocketHeaders,
+						signal: websocketSignal,
+						callerSignal: options?.signal,
+						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs
+					});
+					finishWebSocket = websocket.finish;
+					observePrompt?.(websocket.request, {
+						egress: "responses-websocket",
+						payloadVariant: "initial"
+					});
+					transport = "websocket";
+					emitModelTransportDebug(log, `[responses] websocket_selected provider=${model.provider} api=${model.api} model=${model.id} mode=${websocketMode} reused=${websocket.reusedConnection} continuation=${websocket.continuationStatus === "continued"} continuationStatus=${websocket.continuationStatus} sessionIdHash=${redactIdentifier(options?.sessionId)} headersHash=${redactIdentifier(JSON.stringify(Object.entries(websocketHeaders ?? {}).toSorted(([a], [b]) => a.localeCompare(b))))}`);
+					responseStream = { async *[Symbol.asyncIterator]() {
+						let providerAccepted = false;
+						try {
+							for await (const event of websocket.stream) {
+								if (!providerAccepted) {
+									providerAccepted = true;
+									await notifyProviderStreamOpened({
+										options,
+										cancelStream: () => websocket.finish({ keep: false })
+									});
+								}
+								startStream();
+								yield event;
+							}
+						} catch (error) {
+							if (error instanceof OpenAIResponsesWebSocketSafeRetryError) {
+								const encryptedContentRejected = isInvalidEncryptedContentError(error);
+								const recovery = encryptedContentRejected ? await resolveNextResponsesEncryptedContentAttempt({
+									kind: "initial",
+									request: {
+										...websocket.request,
+										stream: true
+									}
+								}, error, { buildFullHistoryRequest: () => buildRequest("full-history") }) : void 0;
+								if (encryptedContentRejected && !recovery) throw error;
+								closeWebSocketForFallback(`safe_server_error code=${error.code} status=${safeDebugValue(error.status)} param=${safeDebugValue(error.param)}`);
+								yield* await createSseStream(recovery?.request ?? await buildRequest("full-history"), recovery?.kind ?? "continuation-rejected", recovery?.rejectedCompaction);
+								return;
+							}
+							if (websocketSignal.aborted || !(error instanceof OpenAIResponsesWebSocketPreDispatchError)) throw error;
+							transport = "sse";
+							logWebSocketFallback("before_first_event");
+							yield* await createSseStream();
+						}
+					} };
+				} catch {
+					closeWebSocketForFallback("setup_failure");
+					responseStream = await createSseStream();
+				}
+				else responseStream = await createSseStream();
+				try {
+					const terminal = await processResponsesStream(responseStream, output, stream, model, {
+						...config.pricingOptions?.(responsesOptions, model),
+						firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
+						abortFirstEventStream: firstEvent.abort,
+						onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+						signal: options?.signal,
+						reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+							authProfileId: responsesOptions?.authProfileId,
+							sessionId: options?.sessionId
+						})
+					});
+					finishWebSocket?.();
+					if (options?.signal?.aborted) throw transportAbortError(options.signal);
+					if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+					if (continuationClaim && continuationBaseline && terminal) continuationClaim.commit(continuationBaseline, terminal);
+				} catch (error) {
+					finishWebSocket?.({ keep: false });
+					throw error;
+				}
+				emitModelTransportDebug(log, `[responses] completed provider=${model.provider} api=${model.api} model=${model.id} transport=${transport} elapsedMs=${Date.now() - requestStartedAt}`);
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: options?.signal
 				});
-				stream.end();
 			} catch (error) {
+				if (compactRequest) {
+					compactRequest.reject(error);
+					failTransportStream({
+						stream,
+						output,
+						signal: options?.signal,
+						error
+					});
+					return;
+				}
 				if (error instanceof ResponsesStreamFailure && error.observation) logResponsesFailedNoDetails(error.observation);
 				log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error));
-				assignTransportErrorDetails(output, error, options?.signal);
-				stream.push({
-					type: "error",
-					reason: output.stopReason,
-					error: output
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error
 				});
-				stream.end();
 			} finally {
+				continuationClaim?.release();
 				firstEventAbort?.dispose();
 			}
 		})();
@@ -3480,12 +3925,13 @@ function createResponsesTransportExecutor(config) {
 function createOpenAIResponsesTransportStreamFn() {
 	return createResponsesTransportExecutor({
 		streamRequest: true,
+		httpContinuation: true,
 		createClient: createOpenAIResponsesClient,
 		buildRequest: buildOpenAIResponsesParams,
 		createResponseStream: createResponsesStreamWithEncryptedContentRetry,
-		pricingOptions: (options) => ({
+		pricingOptions: (options, model) => ({
 			serviceTier: options?.serviceTier,
-			applyServiceTierPricing
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 		})
 	});
 }
@@ -3494,18 +3940,8 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		outputApi: "azure-openai-responses",
 		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
 		createClient: createAzureOpenAIClient,
-		buildRequest: (model, context, options, metadata) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata),
-		createResponseStream: async ({ client, request, requestOptions, observePrompt }) => {
-			observePrompt?.(request, {
-				egress: "responses-sdk",
-				payloadVariant: "initial"
-			});
-			const { data, response } = await client.responses.create(request, requestOptions).withResponse();
-			return {
-				stream: data,
-				response
-			};
-		}
+		buildRequest: (model, context, options, metadata, replayMode) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata, replayMode),
+		createResponseStream: createResponsesStreamWithEncryptedContentRetry
 	});
 }
 function normalizeAzureBaseUrl(baseUrl) {
@@ -3533,8 +3969,8 @@ function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHead
 		apiVersion: resolveAzureOpenAIApiVersion()
 	});
 }
-function buildAzureOpenAIResponsesParams(model, context, options, deploymentName, metadata) {
-	const params = buildOpenAIResponsesParams(model, context, options, metadata);
+function buildAzureOpenAIResponsesParams(model, context, options, deploymentName, metadata, replayMode = "checkpoint") {
+	const params = buildOpenAIResponsesParams(model, context, options, metadata, replayMode);
 	params.model = deploymentName;
 	delete params.store;
 	return params;
@@ -3559,11 +3995,8 @@ const responsesTesting = {
 	buildOpenAIResponsesReasoningReplayMetadata,
 	isInvalidEncryptedContentError,
 	normalizeResponsesFailedEvent,
-	prepareOpenAIResponsesReasoningItemForReplay,
 	createResponsesStreamWithEncryptedContentRetry,
 	resolveAzureOpenAIApiVersion,
-	stripResponsesRequestEncryptedContent,
-	tagOpenAIResponsesReasoningReplayItem,
 	summarizeResponsesFailedNoDetailsObservation,
 	summarizeResponsesPayload,
 	summarizeResponsesTools,
@@ -3572,6 +4005,51 @@ const responsesTesting = {
 };
 if (process.env.VITEST || false) globalThis.openclawOpenAIResponsesTransportTestApi = responsesTesting;
 //#endregion
+//#region packages/ai/src/transports/provider-compaction-replay.ts
+/** Whether provider replay state is a prefix-bound server compaction checkpoint. */
+function isCompactionReplayCheckpoint(replay) {
+	const type = replay && typeof replay === "object" ? replay.type : void 0;
+	return type === "anthropic-compaction" || type === "openai-responses-compaction" || type === "openai-responses-retained-compaction";
+}
+/** Strip prefix-bound checkpoints after local history rewrites. */
+function stripCompactionReplayCheckpoint(message) {
+	if (!isCompactionReplayCheckpoint(message.providerReplay)) return message;
+	const replaySafeMessage = { ...message };
+	delete replaySafeMessage.providerReplay;
+	return replaySafeMessage;
+}
+/** Strip prefix-bound checkpoint state from an in-place message rewrite. */
+function stripCompactionReplayCheckpointInPlace(message) {
+	if (isCompactionReplayCheckpoint(message.providerReplay)) delete message.providerReplay;
+}
+/** Reindex a prefix-bound checkpoint after known content removals. */
+function replaceCompactionReplayOwnerContent(message, content) {
+	const next = {
+		...message,
+		content
+	};
+	const replay = message.providerReplay;
+	if (!isCompactionReplayCheckpoint(replay)) return next;
+	if (replay.type === "openai-responses-retained-compaction") return next;
+	const replayIndex = replay.replayIndex ?? 0;
+	if (content.length === 0 && message.content.length > 0 || replayIndex > message.content.length) return stripCompactionReplayCheckpoint(next);
+	let sourceIndex = 0;
+	let nextReplayIndex = 0;
+	if (!content.every((block) => {
+		const index = message.content.indexOf(block, sourceIndex);
+		sourceIndex = index + 1;
+		nextReplayIndex += index >= 0 && index < replayIndex ? 1 : 0;
+		return index >= 0;
+	})) return stripCompactionReplayCheckpoint(next);
+	return nextReplayIndex === replayIndex ? next : {
+		...next,
+		providerReplay: {
+			...replay,
+			replayIndex: nextReplayIndex
+		}
+	};
+}
+//#endregion
 //#region packages/ai/src/transports/provider-transport-stream.ts
 const SUPPORTED_TRANSPORT_APIS = /* @__PURE__ */ new Set([
 	"openai-responses",
@@ -3582,10 +4060,7 @@ const SUPPORTED_TRANSPORT_APIS = /* @__PURE__ */ new Set([
 	"google-generative-ai"
 ]);
 const SIMPLE_TRANSPORT_API_ALIAS = {
-	"openai-responses": "openclaw-openai-responses-transport",
-	"openai-chatgpt-responses": "openclaw-openai-chatgpt-responses-transport",
 	"openai-completions": "openclaw-openai-completions-transport",
-	"azure-openai-responses": "openclaw-azure-openai-responses-transport",
 	"anthropic-messages": "openclaw-anthropic-messages-transport",
 	"google-generative-ai": "openclaw-google-generative-ai-transport"
 };
@@ -3638,6 +4113,10 @@ function isTransportAwareApiSupported(api) {
 }
 /** Maps public model APIs to the internal transport API id used by simple runtime dispatch. */
 function resolveTransportAwareSimpleApi(api) {
+	if (OPENAI_RESPONSES_APIS.has(api)) {
+		const alias = `openclaw-${api}-transport`;
+		return OPENAI_RESPONSES_APIS.has(alias) ? alias : void 0;
+	}
 	return SIMPLE_TRANSPORT_API_ALIAS[api];
 }
 /** Creates a managed transport stream only when request overrides require it. */
@@ -3734,12 +4213,12 @@ function resolveProviderStreamApi(model) {
 	];
 	return `${PROVIDER_STREAM_API_PREFIX}${parts.map((part) => encodeURIComponent(part)).join(":")}`;
 }
-function applyProviderSimpleCompletionWrapper(registry, model, cfg) {
+function applyProviderSimpleCompletionWrapper(registry, model, cfg, hookSourceApi = model.api) {
 	if (model.api.startsWith(PROVIDER_SIMPLE_COMPLETION_API_PREFIX)) return model;
 	const sourceProvider = registry.getApiProvider(model.api);
 	if (!sourceProvider) return model;
-	const sourceApi = model.api;
-	const sourceStreamFn = (runtimeModel, context, options) => sourceProvider.streamSimple(projectModel(runtimeModel, { api: sourceApi }), context, options);
+	const dispatchApi = model.api;
+	const sourceStreamFn = (runtimeModel, context, options) => sourceProvider.streamSimple(projectModel(runtimeModel, { api: dispatchApi }), context, options);
 	const streamFn = getAiTransportHost().plugin.wrapSimpleCompletionStream({
 		provider: model.provider,
 		config: cfg,
@@ -3748,6 +4227,7 @@ function applyProviderSimpleCompletionWrapper(registry, model, cfg) {
 			provider: model.provider,
 			modelId: model.id,
 			model,
+			sourceApi: hookSourceApi,
 			streamFn: sourceStreamFn
 		}
 	});
@@ -3781,7 +4261,6 @@ function wrapPluginProviderStream(streamFn) {
 	};
 }
 function prepareProviderStreamModel(params) {
-	if (params.model.api === "google-generative-ai") return;
 	const pluginModel = resolveModelHeaderSentinels(params.model);
 	const providerStreamFn = getAiTransportHost().plugin.resolveProviderStream({
 		provider: params.model.provider,
@@ -3807,20 +4286,19 @@ function prepareModelForSimpleCompletion(params) {
 		cfg,
 		apiRegistry
 	});
-	if (providerStreamModel) return applyProviderSimpleCompletionWrapper(apiRegistry, providerStreamModel, cfg);
+	if (providerStreamModel) return applyProviderSimpleCompletionWrapper(apiRegistry, providerStreamModel, cfg, model.api);
 	const codexTransportModel = prepareCodexSimpleTransportModel(apiRegistry, model, cfg);
-	if (codexTransportModel) return applyProviderSimpleCompletionWrapper(apiRegistry, codexTransportModel, cfg);
+	if (codexTransportModel) return applyProviderSimpleCompletionWrapper(apiRegistry, codexTransportModel, cfg, model.api);
 	const transportAwareModel = prepareTransportAwareSimpleModel(model, { cfg });
 	if (transportAwareModel !== model) {
 		const streamFn = buildTransportAwareSimpleStreamFn(model, { cfg });
-		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return applyProviderSimpleCompletionWrapper(apiRegistry, transportAwareModel, cfg);
+		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return applyProviderSimpleCompletionWrapper(apiRegistry, transportAwareModel, cfg, model.api);
 	}
-	if (model.api === "google-generative-ai") return applyProviderSimpleCompletionWrapper(apiRegistry, getAiTransportHost().prepareGoogleSimpleCompletionModel(apiRegistry, model), cfg);
 	if (model.provider === "anthropic-vertex") {
 		const api = resolveAnthropicVertexSimpleApi(model.baseUrl);
-		if (registerCustomApi(apiRegistry, api, getAiTransportHost().plugin.createAnthropicVertexStream(model))) return applyProviderSimpleCompletionWrapper(apiRegistry, projectModel(model, { api }), cfg);
+		if (registerCustomApi(apiRegistry, api, getAiTransportHost().plugin.createAnthropicVertexStream(model))) return applyProviderSimpleCompletionWrapper(apiRegistry, projectModel(model, { api }), cfg, model.api);
 	}
 	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
 }
 //#endregion
-export { GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, applyAnthropicCacheControlToMessages, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, coerceTransportToolCallArguments, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, hasOpenAICompatibleConversationTurn, isCodeModeModelVisibleToolName, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveCodeModeResponsesVisibleToolNames, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend };
+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, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };