@openclaw/ai 2026.10.1 → 2026.10.5-beta.1

package/dist/{openai-completions-transport-DITBEALX.mjs → openai-completions-transport-OMrn7gnZ.mjs}

@@ -1,35 +1,41 @@
 import { _ as runtimeContextContentToText, f as hasRuntimeContextMarker, p as isRuntimeContextMessage } from "./types-CQc6JNG4.mjs";
-import { r as appendAssistantThinking } from "./event-stream-C5AbCAaZ.mjs";
-import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
+import { r as appendAssistantThinking } from "./event-stream-X2gmsUWv.mjs";
+import { i as asOptionalRecord, o as isRecord, r as asOptionalObjectRecord } from "./record-coerce-CNDovvft.mjs";
 import { s as readNonEmptyStringPreservingWhitespace, t as hasNonEmptyString } from "./string-coerce-CtgOVOSv.mjs";
-import { n as asNonNegativeFiniteNumber } from "./number-coercion-V8-BhME4.mjs";
-import { N as isImageWithMediaPayload, r as getAiTransportHost } from "./host-JpNulOOs.mjs";
-import { _ as isOpenAIGpt54MiniModel, v as isOpenAIGpt55Model, y as isOpenAIGpt56Model } from "./openai-responses-contracts-BKu8O7l4.mjs";
-import { r as uniqueStrings } from "./string-normalization-PN10hf6d.mjs";
-import { o as truncateUtf16Safe } from "./provider-error-DQBE1bUQ.mjs";
-import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-Dj8qeOHT.mjs";
-import { r as emitModelTransportDebug } from "./diagnostics-Caj-4RBA.mjs";
-import { c as supportsModelTools, r as estimateStringChars } from "./text-signature-rOn31nxc.mjs";
-import { i as resolveOpenAICompletionsCompat, l as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-D7hWYB0G.mjs";
-import { i as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-CC5H0iRZ.mjs";
+import { n as asNonNegativeFiniteNumber, r as asPositiveFiniteNumber } from "./number-coercion-C3hztWoY.mjs";
+import { N as isImageWithMediaPayload, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-JWXZWa-c.mjs";
+import { M as resolveOpenAIThinkingApi, S as isOpenAIGpt6Model, _ as isResponsesServiceTierRejection, b as isOpenAIGpt55Model, d as OpenAIResponsesWebSocketSafeRetryError, g as responsesServiceTierObserver, k as supportsOpenAITemperature, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, r as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError, v as nextResponsesServiceTier, x as isOpenAIGpt56Model, y as isOpenAIGpt54MiniModel } from "./openai-responses-contracts-DlKMMTxK.mjs";
+import { r as uniqueStrings } from "./string-normalization-I3ux50s9.mjs";
+import { n as getSessionResourceOwnerId, r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
+import { c as stableStringify, s as truncateUtf16Safe } from "./provider-error-CF9GWCs2.mjs";
+import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-Cr2xKVrS.mjs";
+import { d as hasOnlyResponsesFunctionTools, i as emitModelTransportError, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./diagnostics-tQasYct1.mjs";
+import { f as supportsModelTools, i as providerReplayContextMatches, n as buildProviderReplayContext, o as estimateStringChars, r as isProviderReplayContext } from "./text-signature-B_MB6U_9.mjs";
+import { c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat, l as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-pg1q4uNG.mjs";
+import { i as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-q4Azym9F.mjs";
 import { i as resolveCacheRetention, r as buildCopilotDynamicHeaders } from "./cloudflare-5qSGvIUH.mjs";
-import { E as createToolArgumentPreviewSchedule, O as parseStreamingJson, P as sanitizeSurrogates, S as withProviderResponseHook, _ as sanitizeNonEmptyTransportPayloadText, b as transportAbortError, c as failTransportStream, d as iterateModelStream, l as finalizeTerminalToolCallArguments, s as createWritableTransportEventStream, u as finalizeTransportStream, y as throwIfModelStreamAborted } from "./transport-stream-shared-C5TAc3U_.mjs";
-import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, S as splitSystemPromptRelocatableBoundary, d as describeToolResultMediaPlaceholder, l as codeModeToolSurfaceObserver, m as extractToolResultText, s as prepareModelRequestBody, u as reasoningTagTextPolicy, w as stripSystemPromptRelocatableBoundary, x as splitSystemPromptCacheBoundary } from "./simple-options-wW3117Fu.mjs";
-import { C as log, D as readOpenAICompletionsReasoningBatch, E as readOpenAICompletionsContentDeltas, O as resolveOpenAIClientBaseUrl, S as isOpenAICompletionsThinkingEnabled, T as parseOpenAICompletionsUsage, a as enforceCodeModeResponsesToolSurface, d as prepareOpenAITools, f as projectOpenAITools, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, i as buildOpenAISdkRequestOptions, k as resolvePromptCacheKey, l as resolveCodeModeResponsesVisibleToolNames, n as buildOpenAIClientHeaders, p as reconcileOpenAICompletionsToolChoice, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as measureUtf8AppendBytes, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-ildrm49s.mjs";
-import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
-import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-mJ9cL4Qg.mjs";
-import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-DAv1BdTm.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-D8f_oxHj.mjs";
+import { E as createToolArgumentPreviewSchedule, M as racePromiseWithAbortSignal, O as parseStreamingJson, P as sanitizeSurrogates, S as withProviderResponseHook, b as transportAbortError, c as failTransportStream, d as iterateModelStream, h as notifyProviderStreamOpened, l as finalizeTerminalToolCallArguments, s as createWritableTransportEventStream, u as finalizeTransportStream, v as sanitizeTransportPayloadText, y as throwIfModelStreamAborted } from "./transport-stream-shared-DH08b7Il.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, S as splitSystemPromptRelocatableBoundary, d as describeToolResultMediaPlaceholder, l as codeModeToolSurfaceObserver, m as extractToolResultText, s as prepareModelRequestBody, u as reasoningTagTextPolicy, w as stripSystemPromptRelocatableBoundary, x as splitSystemPromptCacheBoundary } from "./simple-options-BARFAzk9.mjs";
+import { $ as replayResponsesReasoningUpdates, A as summarizeResponsesPayload, At as measureUtf8AppendBytes, B as responsesInputFingerprint, C as readResponsesRecoveryEvent, Ct as toOpenAIResponsesToolChoice, D as logResponsesFailedNoDetails, Dt as createResponseModelTracker, E as ResponsesStreamFailure, Ft as resolvePromptCacheKey, G as responsesContinuationRequestFingerprint, H as recordResponsesContinuationState, I as convertResponsesMessages, It as redactIdentifier, Lt as sha256Hex, Mt as readOpenAICompletionsContentDeltas, Nt as readOpenAICompletionsReasoningBatch, O as safeDebugValue, Ot as isOpenAICompletionsThinkingEnabled, P as buildResponsesInputMessage, Pt as resolveOpenAIClientBaseUrl, Q as isConfigurationUpdate, R as readResponsesInputReplayState, S as isInvalidEncryptedContentError, St as reconcileOpenAIResponsesToolChoice, T as resolveNextResponsesEncryptedContentAttempt, Tt as createOpenAIProviderAcceptanceHook, U as resolveResponsesContinuationRequest, V as claimOpenAIResponsesHttpContinuation, W as responsesContinuationPrefixFingerprint, _t as resolveOpenAISimpleReasoningEffort, a as prepareResponsesTools, at as suppressOpenAIResponsesCompaction, bt as projectOpenAITools, c as observeResponsesStream, ct as buildOpenAISdkClientOptions, et as supportsResponsesReasoningUpdate, ft as getCompat, gt as resolveOpenAIRequestReasoning, ht as resolveOpenAIStrictToolFlagWithDiagnostics, j as recordResponsesContextUsage, jt as parseOpenAICompletionsUsage, k as summarizeOpenAITransportError, kt as log, lt as buildOpenAISdkRequestOptions, mt as resolveCodeModeResponsesVisibleToolNames, n as applyResponsesServiceTierPricing, nt as buildOpenAIResponsesReasoningReplayMetadata, ot as assertCodeModeResponsesToolSurface, s as processResponsesStream, st as buildOpenAIClientHeaders, ut as enforceCodeModeResponsesToolSurface, w as resolveAzureOpenAIApiVersion, wt as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, x as createResponsesStreamWithRecovery, xt as reconcileOpenAICompletionsToolChoice, yt as prepareOpenAITools, z as recordResponsesInputReplay } from "./openai-responses-shared-DVGhq5xF.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-CrxwdylR.mjs";
+import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-CUEeSotf.mjs";
+import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-BrV8KdFO.mjs";
+import { t as notifyLlmRequestActivity } from "./llm-request-activity-CfMuh5cC.mjs";
 import { n as resolveOpencodeSessionHeaders } from "./session-affinity-DA4WHv1h.mjs";
 import "./types.mjs";
-import { i as createOpenAIProviderClient, n as resolveProviderSimpleCompletionHeaders, r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-8c_Nj2NS.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.mjs";
-import { f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-DYNePiF8.mjs";
+import { i as createOpenAIProviderClient, n as resolveProviderSimpleCompletionHeaders, r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-LuCaTsSO.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-Dc42hKv6.mjs";
+import { t as boundResponseBody } from "./streaming-byte-guard-DBXr1XYn.mjs";
+import { f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-DDPXsvJP.mjs";
 import { isGoogleGemini3ThinkingLevelModel } from "./internal/google-model-family.mjs";
 import { t as mapOpenAIStopReason } from "./openai-stop-reason-8s70vDXj.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-Ju9VpUGl.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-0-Rsezog.mjs";
+import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-D0dvJMbZ.mjs";
+import { i as isOpenAIResponsesCompactionOutput, l as resolveOpenAIResponsesPayloadPolicy, n as supportsNativeOpenAIResponsesEndpoint, o as sanitizeResponsesImagePayload, r as createBoundedOpenAIResponsesCompactionFetch, s as applyOpenAIResponsesPayloadPolicy, t as isOfficialOpenAIResponsesBaseUrl } from "./openai-responses-endpoint-CinGh4VZ.mjs";
+import { n as withResponsesRequestAcceptance, r as createResponsesPromptEgressObserver, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-D2IFiI0-.mjs";
 import { randomUUID } from "node:crypto";
-import OpenAI from "openai";
+import OpenAI, { AzureOpenAI } from "openai";
+import { ResponsesWS } from "openai/resources/responses/ws.js";
 //#region packages/ai/src/transports/deepseek-dsml-grammar.ts
 const DEEPSEEK_DSML_MARKERS = [
 	"|",
@@ -247,37 +253,33 @@ function applyCompletionsAnthropicCacheControl(payload, cacheControl = { type: "
 * OpenAI Chat Completions compatibility helpers. Some providers only accept
 * role/content messages with plain string content instead of text block arrays.
 */
-function flattenStringOnlyCompletionContent(content) {
-	if (!Array.isArray(content)) return content;
-	const textParts = [];
-	for (const item of content) {
-		if (!item || typeof item !== "object" || item.type !== "text" || typeof item.text !== "string") return content;
-		textParts.push(item.text);
-	}
-	return textParts.join("\n");
-}
 /** Flatten string-only text block content arrays into newline-joined strings. */
 function flattenCompletionMessagesToStringContent(messages) {
 	return messages.map((message) => {
-		if (!message || typeof message !== "object") return message;
-		const content = message.content;
-		const flattenedContent = flattenStringOnlyCompletionContent(content);
-		if (flattenedContent === content) return message;
+		const record = asOptionalObjectRecord(message);
+		const content = record?.content;
+		if (!Array.isArray(content)) return message;
+		const textParts = [];
+		for (const item of content) {
+			const part = asOptionalObjectRecord(item);
+			if (part?.type !== "text" || typeof part.text !== "string") return message;
+			textParts.push(part.text);
+		}
 		return {
-			...message,
-			content: flattenedContent
+			...record,
+			content: textParts.join("\n")
 		};
 	});
 }
 /** Strip completion messages to role/content fields for strict providers. */
 function stripCompletionMessagesToRoleContent(messages) {
 	return messages.map((message) => {
-		if (!message || typeof message !== "object" || Array.isArray(message)) return message;
-		const record = message;
-		const stripped = {};
-		if (Object.hasOwn(record, "role")) stripped.role = record.role;
-		if (Object.hasOwn(record, "content")) stripped.content = record.content;
-		return stripped;
+		const record = asOptionalRecord(message);
+		if (!record) return message;
+		return {
+			...Object.hasOwn(record, "role") ? { role: record.role } : {},
+			...Object.hasOwn(record, "content") ? { content: record.content } : {}
+		};
 	});
 }
 //#endregion
@@ -321,6 +323,15 @@ function createOpenAIEncryptedToolCallReasoningTracker() {
 		}
 	};
 }
+function hasObservableContent(value) {
+	if (typeof value === "string") return value.length > 0;
+	if (Array.isArray(value)) return value.some(hasObservableContent);
+	if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
+	return false;
+}
+function hasOpenAICompletionsDeltaContent(delta) {
+	return Object.entries(delta).some(([field, value]) => field !== "role" && hasObservableContent(value));
+}
 /** Normalize the SDK's legacy single-function lane into its modern tool-call shape. */
 function createOpenAICompletionsToolCallDeltaNormalizer() {
 	let sawModernToolCall = false;
@@ -342,12 +353,6 @@ function createOpenAICompletionsToolCallDeltaNormalizer() {
 		pendingFollowingDeltaBytes += nextDeltaBytes;
 		pendingFollowingDeltas.push(delta);
 	};
-	const hasObservableContent = (value) => {
-		if (typeof value === "string") return value.length > 0;
-		if (Array.isArray(value)) return value.some(hasObservableContent);
-		if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
-		return false;
-	};
 	return (delta, finishReason) => {
 		const ordinaryDelta = { ...delta };
 		delete ordinaryDelta.function_call;
@@ -383,7 +388,7 @@ function createOpenAICompletionsToolCallDeltaNormalizer() {
 		}];
 		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
 		const leadingDeltas = [];
-		if (Object.entries(ordinaryDelta).some(([field, value]) => field !== "role" && hasObservableContent(value))) {
+		if (hasOpenAICompletionsDeltaContent(ordinaryDelta)) {
 			if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
 			else leadingDeltas.push({
 				delta: ordinaryDelta,
@@ -435,10 +440,7 @@ function finalizeOpenAICompletionsToolCalls(output, options = {}) {
 	const isToolCall = (block) => block.type === "toolCall";
 	const hasToolCalls = output.content.some(isToolCall);
 	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
-	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => {
-		const candidate = block;
-		return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
-	})) output.stopReason = "toolUse";
+	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => block.type === "text" && block.text.trim().length > 0)) output.stopReason = "toolUse";
 	if (output.stopReason !== "toolUse") {
 		if (hasToolCalls) output.content = output.content.filter((block) => !isToolCall(block));
 		return;
@@ -519,7 +521,7 @@ function convertMessages(model, context, compat, options = {}) {
 		});
 		if (isRuntimeContextMessage(msg)) {
 			params.push({
-				role: model.reasoning && compat.supportsDeveloperRole ? "developer" : "system",
+				role: compat.supportsDeveloperRole ? "developer" : "user",
 				content: sanitizeSurrogates(runtimeContextContentToText(msg.content))
 			});
 			options.cacheOptOutIndexes?.add(params.length - 1);
@@ -617,7 +619,7 @@ function convertMessages(model, context, compat, options = {}) {
 				const images = toolMsg.content.filter(isImageWithMediaPayload);
 				const toolResultMsg = {
 					role: "tool",
-					content: sanitizeNonEmptyTransportPayloadText(textResult, mediaPlaceholder),
+					content: textResult.trim() ? textResult : mediaPlaceholder ?? "(no output)",
 					tool_call_id: toolMsg.toolCallId
 				};
 				if (compat.requiresToolResultName && toolMsg.toolName) toolResultMsg.name = toolMsg.toolName;
@@ -678,24 +680,36 @@ function relocateNonBehavioralRegion(args) {
 	}
 }
 //#endregion
-//#region packages/ai/src/transports/openai-completions-direct-policy.ts
-function applyDirectCompletionsReasoningAndRouting(params, model, reasoning, compat) {
+//#region packages/ai/src/transports/openai-completions-policy.ts
+function applyCompletionsReasoningAndRouting(params, model, reasoning, compat, mode) {
+	const direct = mode === "direct";
 	const nativeEffort = compat.thinkingFormat === "openrouter" ? void 0 : reasoning.effort;
-	const reasoningEnabled = reasoning.thinkingEnabled ?? false;
-	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = reasoningEnabled ? {
-		type: "enabled",
-		clear_thinking: false
-	} : { type: "disabled" };
-	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = reasoningEnabled;
-	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = {
-		enable_thinking: reasoningEnabled,
-		preserve_thinking: true
-	};
-	else if ((compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "together") && model.reasoning) {
-		if (compat.thinkingFormat === "deepseek") params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
-		else params.reasoning = { enabled: reasoningEnabled };
-		if (reasoningEnabled && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
-	} else if (model.reasoning && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
+	const enabled = reasoning.thinkingEnabled ?? false;
+	if (model.reasoning) {
+		let allowScalarEffort = true;
+		if (direct && compat.thinkingFormat === "zai") {
+			params.thinking = enabled ? {
+				type: "enabled",
+				clear_thinking: false
+			} : { type: "disabled" };
+			allowScalarEffort = false;
+		} else if (compat.thinkingFormat === "qwen") {
+			params.enable_thinking = enabled;
+			allowScalarEffort = false;
+		} else if (compat.thinkingFormat === "qwen-chat-template") {
+			params.chat_template_kwargs = {
+				enable_thinking: enabled,
+				...direct ? { preserve_thinking: true } : {}
+			};
+			allowScalarEffort = false;
+		} else if (compat.thinkingFormat === "together" || direct && compat.thinkingFormat === "deepseek") {
+			if (compat.thinkingFormat === "deepseek") params.thinking = { type: enabled ? "enabled" : "disabled" };
+			else params.reasoning = { enabled };
+			allowScalarEffort = enabled;
+		}
+		if (allowScalarEffort && compat.supportsReasoningEffort && (direct ? nativeEffort !== void 0 : nativeEffort)) params.reasoning_effort = nativeEffort;
+	}
+	if (!direct) return;
 	if (compat.openRouterRouting) params.provider = compat.openRouterRouting;
 	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
 		const routing = model.compat.vercelGatewayRouting;
@@ -738,21 +752,15 @@ function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
 	}
 	if (sigById.size === 0 && !fallbackSig) return;
 	for (const message of outgoingMessages) {
-		const toolCalls = message.tool_calls;
+		const toolCalls = "tool_calls" in message ? message.tool_calls : void 0;
 		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) {
+			let sig = sigById.get(toolCall.id) ?? fallbackSig;
+			if (sig) {
 				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;
+			if (!sig) continue;
+			Object.assign(toolCall, { extra_content: { google: { thought_signature: sig } } });
 		}
 	}
 }
@@ -762,9 +770,6 @@ const COMPLETIONS_REASONING_REPLAY_FIELDS = [
 	"reasoning",
 	"reasoning_text"
 ];
-function stripCompletionsReasoningReplayFields(record) {
-	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) delete record[field];
-}
 function sanitizeOpenRouterReasoningReplayFields(record) {
 	const reasoningDetails = record.reasoning_details;
 	if (typeof reasoningDetails === "string") {
@@ -776,12 +781,6 @@ function sanitizeOpenRouterReasoningReplayFields(record) {
 	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
 	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",
@@ -839,23 +838,21 @@ function shouldTrustReasoningContentReplayMetadata(model) {
 	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)
-	});
+	const preserveOpenRouterReasoning = compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model);
+	const preserveReasoningContent = shouldPreserveReasoningContentReplay(model, compat);
+	for (const message of outgoingMessages) {
+		if (message.role !== "assistant") continue;
+		if (preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(message);
+		else {
+			const record = message;
+			for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) {
+				if (preserveReasoningContent && field === "reasoning_content" && typeof record[field] === "string") continue;
+				delete record[field];
+			}
+		}
+	}
 }
 //#endregion
 //#region packages/ai/src/transports/openai-completions-params.ts
@@ -882,7 +879,8 @@ function resolveOpenAICompletionsMaxTokens(model, options) {
 	};
 }
 function resolveOpenAICompletionsModelMaxTokens(model) {
-	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
+	const maxTokens = asPositiveFiniteNumber(model.maxTokens);
+	return maxTokens === void 0 ? void 0 : Math.floor(maxTokens);
 }
 const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
 const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
@@ -897,12 +895,11 @@ function estimateJsonChars(value, fallback) {
 function estimateOpenAICompletionsInputTokens(payload) {
 	let adjustedChars = 0;
 	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
-	if (Array.isArray(payload.tools) && payload.tools.length > 0) adjustedChars += estimateJsonChars(payload.tools, 1024);
+	if (payload.tools?.length) adjustedChars += estimateJsonChars(payload.tools, 1024);
 	if (payload.response_format !== void 0) adjustedChars += estimateJsonChars(payload.response_format, 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;
@@ -933,35 +930,6 @@ function estimateOpenAICompletionsContentChars(value) {
 	}
 	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 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 };
-}
-/** Return whether the binary control replaces scalar reasoning effort. */
-function applyBinaryCompletionsThinkingParams(params) {
-	if (!params.modelReasoning) return false;
-	const enabled = params.thinkingEnabled;
-	switch (params.compatThinkingFormat) {
-		case "qwen-chat-template":
-			setQwenChatTemplateThinking(params.payload, enabled);
-			return true;
-		case "qwen":
-			params.payload.enable_thinking = enabled;
-			return true;
-		case "together":
-			params.payload.reasoning = { enabled };
-			return !enabled;
-		default: return false;
-	}
-}
 function convertTools(tools, compat, model, mode) {
 	const prepared = mode === "managed" ? prepareOpenAITools(tools) : void 0;
 	const projection = prepared?.projection ?? projectOpenAITools(tools);
@@ -1012,12 +980,13 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 		"qwen"
 	].includes(model.provider));
 	const cacheOptOutIndexes = /* @__PURE__ */ new Set();
-	let messages = convertMessages(model, context, compat, {
+	const convertedMessages = convertMessages(model, context, compat, {
 		cacheOptOutIndexes,
 		preserveSystemPromptCacheBoundary: cacheControl !== void 0 && !managedCompat?.requiresStringContent
 	});
+	let messages = convertedMessages;
 	if (managedCompat) {
-		applyCompletionsReplay(messages, context, model, managedCompat);
+		applyCompletionsReplay(convertedMessages, context, model, managedCompat);
 		if (managedCompat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
 		if (managedCompat.requiresStringContent) messages = flattenCompletionMessagesToStringContent(messages);
 	}
@@ -1025,10 +994,10 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 	const params = {
 		model: model.id,
 		messages,
-		stream: true,
+		stream: (options?.streaming ?? model.params?.streaming) !== false,
 		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat)
 	};
-	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
+	if (params.stream && compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
 	if (compat.supportsStore) params.store = false;
 	if (policy.mode === "direct" || compat.supportsPromptCacheKey && promptCacheKey) params.prompt_cache_key = compat.supportsPromptCacheKey ? promptCacheKey : void 0;
 	if (options?.temperature !== void 0) params.temperature = options.temperature;
@@ -1051,13 +1020,13 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 			if (policy.mode === "direct") directToolProjection = converted.projection;
 			if (converted.tools.length > 0 || policy.mode === "managed" && converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
 			else if (hasToolCallHistory(context.messages)) params.tools = [];
-			if (policy.mode === "direct" && compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
+			if (policy.mode === "direct" && params.stream && compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
 			if (policy.mode === "managed" && 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 (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && params.tools?.length) params.tool_choice = "auto";
 		} else if (hasToolCallHistory(context.messages)) params.tools = [];
-		if (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
+		if (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && params.tools?.length === 0) {
 			delete params.tools;
 			delete params.tool_choice;
 		}
@@ -1074,7 +1043,7 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 		...model,
 		compat: model.compat ?? void 0
 	}, simpleReasoning)) ?? (usesBinaryOpenRouterThinking ? void 0 : "high");
-	const reasoning = resolveOpenAIRequestReasoning(model, requestedEffort);
+	const reasoning = resolveOpenAIRequestReasoning(model, requestedEffort, compat.reasoningEffortForOff);
 	const { effort, thinkingEnabled } = reasoning;
 	{
 		const maxTokenBudget = policy.mode === "direct" ? {
@@ -1082,7 +1051,7 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 			clampToModelMaxTokens: true
 		} : resolveOpenAICompletionsMaxTokens(model, options);
 		const effectiveMaxTokens = maxTokenBudget.maxTokens;
-		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
+		const effectiveContextTokens = asPositiveFiniteNumber(model.contextTokens) ?? asPositiveFiniteNumber(model.contextWindow);
 		let clampedMaxTokens = effectiveMaxTokens;
 		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
 		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
@@ -1107,17 +1076,8 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 		if (usesBinaryOpenRouterThinking && thinkingEnabled !== void 0) params.reasoning = { enabled: thinkingEnabled };
 		else if (effort !== void 0) params.reasoning = { effort };
 	}
-	if (policy.mode === "direct") applyDirectCompletionsReasoningAndRouting(params, model, reasoning, compat);
-	else {
-		const suppressScalarEffort = applyBinaryCompletionsThinkingParams({
-			compatThinkingFormat: compat.thinkingFormat,
-			modelReasoning: model.reasoning,
-			payload: params,
-			thinkingEnabled: thinkingEnabled ?? false
-		});
-		if (!isOpenRouter && effort && model.reasoning && compat.supportsReasoningEffort && !suppressScalarEffort) params.reasoning_effort = effort;
-		if (compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools, !managedCompat?.requiresStringContent);
-	}
+	applyCompletionsReasoningAndRouting(params, model, reasoning, compat, policy.mode);
+	if (policy.mode === "managed" && compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools, !managedCompat?.requiresStringContent);
 	if (params.tools?.length && isKnownOpenAICompletionsEndpoint(model)) {
 		if (isOpenAIGpt56Model(model)) params.reasoning_effort = "none";
 		else if (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model)) delete params.reasoning_effort;
@@ -1487,7 +1447,8 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
 	const directMode = options?.mode === "direct";
 	const emitReasoning = options?.emitReasoning ?? true;
-	const compat = getCompat(model);
+	const openAIModel = model;
+	const compat = getCompat(openAIModel);
 	const visibleReasoningDetailTypes = new Set(compat.visibleReasoningDetailTypes);
 	const shouldFilterDeepSeekDsmlText = !directMode && compat.thinkingFormat === "deepseek";
 	const deepSeekTextFilter = shouldFilterDeepSeekDsmlText ? createDeepSeekTextFilter() : null;
@@ -1496,31 +1457,37 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 	const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
 	if (options?.strictReasoningTags) reasoningTagTextPartitioner.markStrict();
 	let currentBlock = null;
-	let directTextBlock = null;
-	let directThinkingBlock = null;
+	const directContent = { block: 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 encryptedReasoning = createOpenAIEncryptedToolCallReasoningTracker();
 	const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
 	const provisionalCommentaryTags = directMode ? options.provisionalCommentaryTags : /* @__PURE__ */ new Map();
-	const contentBlockIndices = /* @__PURE__ */ new WeakMap();
-	const toolCallBlockIndices = /* @__PURE__ */ new WeakMap();
+	const blockIndices = /* @__PURE__ */ new WeakMap();
 	let explicitVisibleTextBlocks;
 	const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
 	let finishReason;
 	let sawNativeToolCallDelta = false;
-	const blockIndex = () => directMode && currentBlock && currentBlock.type !== "toolCall" ? contentBlockIndices.get(currentBlock) ?? output.content.length - 1 : output.content.length - 1;
+	const blockIndex = () => directMode && currentBlock && currentBlock.type !== "toolCall" ? blockIndices.get(currentBlock) ?? output.content.length - 1 : output.content.length - 1;
 	let chunkPushedEvent = false;
 	const pushStreamEvent = (event) => {
 		chunkPushedEvent = true;
 		stream.push(event);
 	};
+	const appendToolCallBlock = (block) => {
+		output.content.push(block);
+		blockIndices.set(block, output.content.length - 1);
+		pushStreamEvent({
+			type: "toolcall_start",
+			contentIndex: blockIndices.get(block) ?? -1,
+			partial: output
+		});
+	};
 	const queuePostToolCallDelta = (next) => {
 		const nextBytes = Buffer.byteLength(next.text, "utf8");
 		if (pendingPostToolCallBytes + nextBytes > MAX_POST_TOOL_CALL_BUFFER_BYTES) throw new Error("Exceeded post-tool-call delta buffer limit");
@@ -1532,88 +1499,62 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 		}
 		previous.text += next.text;
 	};
-	const appendThinkingDeltaInternal = (reasoningDelta) => {
-		if (directMode && directThinkingBlock) currentBlock = directThinkingBlock;
-		if (!currentBlock || currentBlock.type !== "thinking") {
-			options?.beforeContentBlock?.("thinking");
-			const thinkingSignature = reasoningDelta.signature;
-			currentBlock = {
+	const appendContentDelta = (delta) => {
+		flushPendingPostToolCallDeltas();
+		if (directMode && directContent.block?.type === delta.kind) currentBlock = directContent.block;
+		if (delta.kind === "text" && currentBlock?.type === "text" && currentTextSource !== delta.source) currentBlock = null;
+		if (!currentBlock || currentBlock.type !== delta.kind) {
+			options?.beforeContentBlock?.(delta.kind);
+			if (delta.kind === "text") {
+				currentBlock = {
+					type: "text",
+					text: ""
+				};
+				currentTextSource = delta.source;
+				if (delta.source === "reasoning_detail") (explicitVisibleTextBlocks ??= /* @__PURE__ */ new Set()).add(currentBlock);
+			} else currentBlock = {
 				type: "thinking",
 				thinking: "",
-				...thinkingSignature ? { thinkingSignature } : {}
+				...delta.signature ? { thinkingSignature: delta.signature } : {}
 			};
-			if (directMode) {
-				directTextBlock = null;
-				directThinkingBlock = currentBlock;
-			}
+			if (directMode) directContent.block = currentBlock;
 			output.content.push(currentBlock);
-			contentBlockIndices.set(currentBlock, output.content.length - 1);
+			blockIndices.set(currentBlock, output.content.length - 1);
 			pushStreamEvent({
-				type: "thinking_start",
+				type: `${delta.kind}_start`,
 				contentIndex: blockIndex(),
 				partial: output
 			});
 		}
-		appendAssistantThinking(currentBlock, reasoningDelta.text);
-		pushStreamEvent({
-			type: "thinking_delta",
+		if (currentBlock.type === "thinking") appendAssistantThinking(currentBlock, delta.text);
+		else {
+			currentBlock.text += delta.text;
+			if (pendingInterruptedTextBlock && delta.text.trim()) {
+				confirmedInterruptedTextBlock = pendingInterruptedTextBlock;
+				pendingInterruptedTextBlock = null;
+			}
+		}
+		const event = {
 			contentIndex: blockIndex(),
-			delta: reasoningDelta.text,
+			delta: delta.text
+		};
+		if (delta.kind === "thinking") pushStreamEvent({
+			type: "thinking_delta",
+			...event,
 			partial: output
 		});
-	};
-	const appendTextDeltaInternal = (text, source) => {
-		if (directMode && directTextBlock) currentBlock = directTextBlock;
-		if (currentBlock?.type === "text" && currentTextSource !== source) currentBlock = null;
-		if (!currentBlock || currentBlock.type !== "text") {
-			options?.beforeContentBlock?.("text");
-			currentBlock = {
-				type: "text",
-				text: ""
-			};
-			currentTextSource = source;
-			if (directMode) {
-				directTextBlock = currentBlock;
-				directThinkingBlock = null;
-			}
-			if (source === "reasoning_detail") (explicitVisibleTextBlocks ??= /* @__PURE__ */ new Set()).add(currentBlock);
-			output.content.push(currentBlock);
-			contentBlockIndices.set(currentBlock, output.content.length - 1);
-			pushStreamEvent({
-				type: "text_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
-		}
-		currentBlock.text += text;
-		if (pendingInterruptedTextBlock && text.trim()) {
-			confirmedInterruptedTextBlock = pendingInterruptedTextBlock;
-			pendingInterruptedTextBlock = null;
-		}
-		pushStreamEvent({
+		else pushStreamEvent({
 			type: "text_delta",
-			contentIndex: blockIndex(),
-			delta: text,
+			...event,
 			...directMode ? { partial: output } : {}
 		});
 	};
 	const flushPendingPostToolCallDeltas = () => {
-		if (isFlushingPendingPostToolCallDeltas || currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
-		isFlushingPendingPostToolCallDeltas = true;
+		if (currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
 		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;
-	};
-	const appendThinkingDelta = (reasoningDelta) => {
-		flushPendingPostToolCallDeltas();
-		appendThinkingDeltaInternal(reasoningDelta);
-	};
-	const appendTextDelta = (text, source) => {
-		flushPendingPostToolCallDeltas();
-		appendTextDeltaInternal(text, source);
+		for (const delta of bufferedDeltas) if (delta.kind === "text" || emitReasoning) appendContentDelta(delta);
 	};
 	const appendVisibleTextDelta = (text) => {
 		if (!text) return;
@@ -1621,20 +1562,22 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 			kind: "text",
 			text
 		});
-		else appendTextDelta(text);
+		else appendContentDelta({
+			kind: "text",
+			text
+		});
 	};
 	const appendReasoningDeltas = (reasoningDeltas) => {
-		for (const reasoningDelta of reasoningDeltas) {
-			if (reasoningDelta.kind === "thinking" && !emitReasoning) continue;
+		for (const delta of reasoningDeltas) {
+			if (delta.kind === "thinking" && !emitReasoning) continue;
 			if (currentBlock?.type === "toolCall" && !directMode) {
-				queuePostToolCallDelta({ ...reasoningDelta });
+				queuePostToolCallDelta({ ...delta });
 				continue;
 			}
-			if (reasoningDelta.kind === "text") appendTextDelta(reasoningDelta.text, reasoningDelta.source);
-			else if (emitReasoning) appendThinkingDelta(directMode && model.provider === "opencode-go" && reasoningDelta.signature === "reasoning" ? {
-				...reasoningDelta,
+			appendContentDelta(delta.kind === "thinking" && directMode && model.provider === "opencode-go" && delta.signature === "reasoning" ? {
+				...delta,
 				signature: "reasoning_content"
-			} : reasoningDelta);
+			} : delta);
 		}
 	};
 	const appendRecoveredToolCall = (toolCall) => {
@@ -1650,18 +1593,11 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 			arguments: toolCall.arguments,
 			partialArgs: toolCall.partialArgs
 		};
-		toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
 		currentBlock = block;
-		output.content.push(block);
-		toolCallBlockIndices.set(block, output.content.length - 1);
-		pushStreamEvent({
-			type: "toolcall_start",
-			contentIndex: toolCallBlockIndices.get(block) ?? -1,
-			partial: output
-		});
+		appendToolCallBlock(block);
 		pushStreamEvent({
 			type: "toolcall_delta",
-			contentIndex: toolCallBlockIndices.get(block) ?? -1,
+			contentIndex: blockIndices.get(block) ?? -1,
 			delta: toolCall.partialArgs,
 			partial: output
 		});
@@ -1676,24 +1612,25 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 			for (const part of parts) appendVisibleTextDelta(part);
 		}
 	};
-	const appendFilteredVisibleTextDelta = (text) => {
-		appendRecoveredParts(deepSeekToolCallRecoverer?.push(text) ?? [{
+	const appendPartitionedVisibleDelta = (delta) => {
+		if (delta.kind === "text") appendRecoveredParts(deepSeekToolCallRecoverer?.push(delta.text) ?? [{
 			kind: "text",
-			text
+			text: delta.text
 		}]);
 	};
-	const appendPartitionedVisibleDelta = (delta) => {
-		if (delta.kind === "text") appendFilteredVisibleTextDelta(delta.text);
-	};
 	const emitReasoningUsageActivity = (hasReasoningUsageActivity) => {
 		if (directMode || !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: "" });
+		appendContentDelta({
+			kind: "thinking",
+			text: ""
+		});
 	};
 	const flushReasoningTagTextPartitioner = () => {
-		for (const delta of reasoningTagTextPartitioner.flush()) appendPartitionedVisibleDelta(delta);
+		const recoverUnclosed = output.stopReason !== "length" && output.stopReason !== "error" && output.stopReason !== "aborted";
+		for (const delta of reasoningTagTextPartitioner.flush({ recoverUnclosed })) appendPartitionedVisibleDelta(delta);
 	};
 	const flushGemmaToolCallRecoverer = (allowRecovery = true) => {
 		for (const part of gemmaToolCallRecoverer?.flush(allowRecovery) ?? []) if (part.kind === "toolCall") appendRecoveredToolCall(part);
@@ -1705,7 +1642,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 		if (currentBlock?.type !== "text") return;
 		if (currentTextSource !== "reasoning_detail" && currentBlock.text.trim()) pendingInterruptedTextBlock = currentBlock;
 		currentBlock = null;
-		if (directMode) directTextBlock = null;
+		if (directMode) directContent.block = null;
 		currentTextSource = void 0;
 	};
 	const beginReasoning = (hasFollowingVisibleText, forceStrict = false) => {
@@ -1731,32 +1668,25 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 		throwIfModelStreamAborted(options?.signal);
 		chunkPushedEvent = false;
 		if (!rawChunk || typeof rawChunk !== "object") continue;
-		notifyLlmRequestActivity(options?.signal);
 		const chunk = rawChunk;
 		output.responseId ||= chunk.id;
 		if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
-		let hasReasoningUsageActivity = false;
-		if (chunk.usage) {
-			output.usage = parseOpenAICompletionsUsage(chunk.usage, model, { includeReasoningTokens: !directMode });
-			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(chunk.usage);
-		}
 		const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
+		const usage = chunk.usage || choice?.usage;
+		const hasReasoningUsageActivity = Boolean(asPositiveFiniteNumber(usage?.completion_tokens_details?.reasoning_tokens));
+		if (usage) output.usage = parseOpenAICompletionsUsage(usage, model, { includeReasoningTokens: !directMode });
+		const rawChoiceDelta = choice?.delta ?? choice?.message;
+		notifyLlmRequestActivity(options?.signal, Boolean(usage || choice?.finish_reason || rawChoiceDelta && (rawChoiceDelta.tool_calls?.length || hasOpenAICompletionsDeltaContent(rawChoiceDelta))));
 		if (!choice) {
 			emitReasoningUsageActivity(hasReasoningUsageActivity);
 			continue;
 		}
-		const choiceUsage = choice.usage;
-		if (!chunk.usage && choiceUsage) {
-			output.usage = parseOpenAICompletionsUsage(choiceUsage, model, { includeReasoningTokens: !directMode });
-			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(choiceUsage);
-		}
 		if (choice.finish_reason) {
 			const finishReasonResult = mapOpenAIStopReason(choice.finish_reason, { allowSingularToolCall: true });
 			output.stopReason = finishReasonResult.stopReason;
 			finishReason = finishReasonResult.stopReason;
 			if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
 		}
-		const rawChoiceDelta = choice.delta ?? choice.message;
 		if (!rawChoiceDelta) {
 			emitReasoningUsageActivity(hasReasoningUsageActivity);
 			continue;
@@ -1784,7 +1714,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 				beginReasoning(contentDeltaIndex < lastVisibleTextIndex);
 				if (emitReasoning) {
 					if (currentBlock?.type === "toolCall" && !directMode) queuePostToolCallDelta(contentDelta);
-					else appendThinkingDelta(contentDelta);
+					else appendContentDelta(contentDelta);
 				}
 			}
 			if (!hasReasoningThinking) appendReasoningDeltas(reasoningDeltas);
@@ -1805,7 +1735,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 						}
 						const initialSig = directMode ? void 0 : extractToolCallThoughtSignature(toolCall);
 						options?.beforeContentBlock?.("toolCall");
-						if (directMode) directThinkingBlock = null;
+						if (directMode && directContent.block?.type === "thinking") directContent.block = null;
 						block = {
 							type: "toolCall",
 							id: toolCall.id || "",
@@ -1816,13 +1746,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 						};
 						encryptedReasoning.rememberToolCall(block.id, block);
 						toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
-						output.content.push(block);
-						toolCallBlockIndices.set(block, output.content.length - 1);
-						pushStreamEvent({
-							type: "toolcall_start",
-							contentIndex: toolCallBlockIndices.get(block) ?? -1,
-							partial: output
-						});
+						appendToolCallBlock(block);
 					}
 					if (streamIndex !== void 0 && !toolCallBlocksByIndex.has(streamIndex)) toolCallBlocksByIndex.set(streamIndex, block);
 					if (toolCall.id) {
@@ -1843,7 +1767,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 					}
 					if (toolArgumentsDelta || directMode) pushStreamEvent({
 						type: "toolcall_delta",
-						contentIndex: toolCallBlockIndices.get(block) ?? -1,
+						contentIndex: blockIndices.get(block) ?? -1,
 						delta: toolArgumentsDelta ?? "",
 						partial: output
 					});
@@ -1865,7 +1789,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 	finalizeOpenAICompletionsToolCalls(output, {
 		allowSilentToolCallPromotion: finishReason === "stop" || sawNativeToolCallDelta && (options?.sawStreamDONE?.() ?? false),
 		onConfirmedToolCall(block, contentIndex) {
-			if (directMode || block.type !== "toolCall") return;
+			if (directMode) return;
 			pushStreamEvent({
 				type: "toolcall_end",
 				contentIndex,
@@ -1878,15 +1802,1203 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 	if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
 	if (output.stopReason === "error" || output.stopReason === "aborted") tagUnresolvedTextAsCommentary(output);
 	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
+	if (!output.usage.contextUsage && !options?.signal?.aborted && output.stopReason !== "error" && output.stopReason !== "aborted") {
+		output.usage.contextUsage = { state: "unavailable" };
+		if (!compat.supportsUsageInStreaming) warnMissingStreamingUsage(openAIModel);
+	}
+}
+const MAX_MISSING_USAGE_HINT_KEYS = 256;
+const missingUsageHintKeys = /* @__PURE__ */ new Set();
+function warnMissingStreamingUsage(model) {
+	if (detectOpenAICompletionsCompat(model).capabilities.endpointClass !== "custom") return;
+	const key = `${model.provider}/${model.id}`;
+	if (missingUsageHintKeys.has(key) || missingUsageHintKeys.size >= MAX_MISSING_USAGE_HINT_KEYS) return;
+	missingUsageHintKeys.add(key);
+	log.warn(`${key} returned no token usage; context size is estimated and token accounting is unavailable. If this endpoint supports stream_options.include_usage, set compat.supportsUsageInStreaming: true on the model in models.providers.${model.provider}.models.`, {
+		provider: model.provider,
+		model: model.id
+	});
 }
 function shouldEmitOpenAICompletionsReasoning(model, options) {
 	if (!model.reasoning) return false;
 	const effort = options?.reasoningEffort ?? options?.reasoning ?? "high";
 	return Boolean(effort) && isOpenAICompletionsThinkingEnabled(effort);
 }
-function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
-	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
+//#endregion
+//#region packages/ai/src/providers/openai-web-search-tools.ts
+function hasResponsesWebSearchTool(tools) {
+	if (!Array.isArray(tools)) return false;
+	return tools.some((tool) => {
+		if (!isRecord(tool)) return false;
+		if (tool.type === "web_search") return true;
+		if (tool.type === "function" && tool.name === "web_search") return true;
+		const fn = tool.function;
+		return isRecord(fn) && fn.name === "web_search";
+	});
+}
+//#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 raiseMinimalReasoningForResponsesWebSearch(params) {
+	if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
+	for (const effort of [
+		"low",
+		"medium",
+		"high"
+	]) {
+		const resolved = resolveOpenAIRequestReasoning(params.model, effort).effort;
+		if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
+	}
+	return params.effort;
+}
+const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
+	"max_output_tokens",
+	"metadata",
+	"prompt_cache_retention",
+	"prompt_cache_options",
+	"service_tier",
+	"temperature",
+	"top_p"
+];
+function stripOpenAICodexResponsesUnsupportedTextFields(params) {
+	const text = params.text;
+	if (!text || typeof text !== "object" || Array.isArray(text)) return;
+	const sanitizedText = { ...text };
+	delete sanitizedText.format;
+	if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
+	else delete params.text;
+}
+function sanitizeOpenAICodexResponsesParams(model, params) {
+	if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
+	for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
+	Object.assign(params, { store: false });
+	stripOpenAICodexResponsesUnsupportedTextFields(params);
+	return params;
+}
+function buildOpenAIResponsesInstructionsText(context) {
+	if (!context.systemPrompt) return;
+	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
+}
+function resolveOpenAIResponsesInstructions(model, context, usesInstructionsField) {
+	if (!usesInstructionsField) return;
+	const instructions = buildOpenAIResponsesInstructionsText(context);
+	if (instructions && instructions.trim().length > 0) return instructions;
+	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
+}
+function buildOpenAIResponsesCompactSystemMessage(model, instructions) {
+	const compat = getCompat(model);
+	const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
+	return buildResponsesInputMessage(role, [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(messages, context) {
+	if (messages.length > 0 || !context.systemPrompt) return;
+	if (!buildOpenAIResponsesInstructionsText(context)) throw new Error("OpenAI Responses requires non-empty input when only systemPrompt is provided.");
+	messages.push(buildResponsesInputMessage("user", [{
+		type: "input_text",
+		text: " "
+	}]));
+}
+function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
+	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "transport-default" });
+	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
+	const replayResponsesItemIds = !usesNativeOpenAICodexResponsesBackend(model) && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
+	const messages = convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
+		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
+		replayReasoningItems: true,
+		replayResponsesItemIds,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId,
+		replayMode
+	});
+	ensureOpenAIResponsesNonEmptyInput(messages, context);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const compat = getCompat(model);
+	const promptCacheKey = compat.supportsPromptCacheKey ? resolvePromptCacheKey(options, cacheRetention) : void 0;
+	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: promptCacheKey,
+		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
+		...instructions ? { instructions } : {},
+		...metadata ? { metadata } : {}
+	};
+	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
+	if (effectiveMaxTokens) params.max_output_tokens = Math.max(effectiveMaxTokens, 16);
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
+	if (options?.topP !== void 0 && (!isOpenAIGpt6Model(model) || resolveOpenAIThinkingApi(model.api) === "azure-openai-responses")) params.top_p = options.topP;
+	if (options?.responseFormat !== void 0) params.text = {
+		...params.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+	};
+	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
+	if (context.tools) {
+		const tools = context.tools;
+		const strict = getAiTransportHost().resolveOpenAIStrictToolSetting(model, {
+			transport: "stream",
+			supportsStrictMode: compat.supportsStrictMode
+		});
+		const { projection, tools: converted } = prepareResponsesTools(tools, strict, model);
+		if (converted.length > 0 || projection.inputToolCount === 0 && projection.diagnostics.length === 0) params.tools = converted;
+		if (options?.toolChoice) {
+			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, projection);
+			if (toolChoice !== void 0) params.tool_choice = toolChoice;
+		}
+	}
+	if (model.reasoning) {
+		const reasoning = options?.reasoning;
+		const requestedEffort = options?.reasoningEffort ?? (reasoning === "none" ? "none" : resolveOpenAISimpleReasoningEffort(model, reasoning)) ?? (options?.reasoningSummary ? "high" : payloadPolicy.defaultManagedReasoningEffort);
+		const resolvedEffort = requestedEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, requestedEffort).effort;
+		if (resolvedEffort !== void 0) {
+			const effort = raiseMinimalReasoningForResponsesWebSearch({
+				model,
+				effort: resolvedEffort,
+				tools: params.tools
+			});
+			const summary = effort !== "none" && (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) ? options.reasoningSummary || "auto" : void 0;
+			params.reasoning = {
+				effort,
+				...summary ? { summary } : {}
+			};
+			if (summary) params.include = ["reasoning.encrypted_content"];
+		}
+	}
+	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
+	return sanitizeOpenAICodexResponsesParams(model, params);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-compact-client.ts
+async function postOpenAIResponsesCompaction(params) {
+	const compactInput = typeof params.request.instructions === "string" && params.request.instructions.length > 0 ? [buildOpenAIResponsesCompactSystemMessage(params.model, params.request.instructions), ...params.request.input ?? []] : params.request.input;
+	const response = await params.client.post("/responses/compact", {
+		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, { timeoutMs: params.options?.timeoutMs }),
+		body: {
+			model: params.request.model,
+			input: compactInput
+		}
+	});
+	const output = isRecord(response) && Array.isArray(response.output) ? response.output : [];
+	const item = output.at(-1);
+	const retainedItems = output.slice(0, -1);
+	const retainedUserMessageCount = retainedItems.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user" && Array.isArray(candidate.content)).length;
+	const inputUserMessageCount = Array.isArray(params.request.input) ? params.request.input.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user").length : 0;
+	const retainedMessagePrefixSupported = supportsNativeOpenAIResponsesEndpoint(params.model);
+	const usage = isRecord(response) && isRecord(response.usage) ? response.usage : void 0;
+	if (!isRecord(response) || response.object !== "response.compaction" || !isOpenAIResponsesCompactionOutput(output, params.model) || retainedItems.length > 0 && (!retainedMessagePrefixSupported || retainedUserMessageCount !== inputUserMessageCount) || !isRecord(item) || item.type !== "compaction" || typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0 || !usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") throw new Error("Responses compact endpoint did not return one trailing compaction item");
+	return {
+		output,
+		item,
+		historyMode: retainedUserMessageCount > 0 ? "retained-users" : "compacted-prefix",
+		usage,
+		model: params.model,
+		replayMetadata: buildOpenAIResponsesReasoningReplayMetadata(params.model, {
+			authProfileId: params.options?.authProfileId,
+			sessionId: params.options?.sessionId
+		})
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-compact-request.ts
+const COMPACT_REQUEST = Symbol("openaiResponsesCompactRequest");
+function claimResponsesCompactRequest(options) {
+	const controller = options ? Reflect.get(options, COMPACT_REQUEST) : void 0;
+	if (controller?.claimed === false) {
+		controller.claimed = true;
+		return controller;
+	}
+}
+/** Run a compact-endpoint request through the session's prepared stream stack. */
+async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context, options) {
+	const preparedOptions = { ...options };
+	let resolveResult;
+	let rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	const controller = {
+		claimed: false,
+		resolve: resolveResult,
+		reject: rejectResult
+	};
+	Reflect.set(preparedOptions, COMPACT_REQUEST, controller);
+	const stream = await Promise.resolve(streamFn(model, context, preparedOptions));
+	if (!controller.claimed) throw new Error("Prepared stream did not reach an OpenAI Responses transport");
+	try {
+		return await result;
+	} finally {
+		await stream.result().catch(() => void 0);
+	}
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-reasoning-state.ts
+/** Save only admitted settings and hashes, never another copy of the conversation. */
+function recordResponsesReasoningState(message, model, identity, request, output) {
+	if (!supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || message.providerReplay || output.some((item) => isRecord(item) && item.type === "compaction")) return;
+	const reasoning = {
+		...buildProviderReplayContext(model, identity),
+		effort: request.reasoning.effort,
+		controls: request.input.flatMap((item, index) => isConfigurationUpdate(item) ? [{
+			index,
+			item
+		}] : []),
+		inputLength: request.input.length,
+		outputLength: output.length,
+		prefixHash: responsesContinuationPrefixFingerprint(request.input, output),
+		requestHash: responsesContinuationRequestFingerprint(request)
+	};
+	Object.assign(message, { openclawResponsesInputReplay: {
+		...readResponsesInputReplayState(message),
+		reasoning
+	} });
+}
+/** A cold transport can replay controls, but cannot resurrect a server response handle. */
+function restoreResponsesReasoningState(context, model, identity, request) {
+	const latest = context.messages.findLast((message) => message.role === "assistant");
+	const state = latest ? readResponsesInputReplayState(latest)?.reasoning : void 0;
+	if (!isRecord(state)) return request;
+	const { effort, inputLength, outputLength, controls, prefixHash, requestHash } = state;
+	if (!isProviderReplayContext(state) || !providerReplayContextMatches(state, buildProviderReplayContext(model, identity)) || latest?.providerReplay || !supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || request.input.some(isConfigurationUpdate) || typeof effort !== "string" || typeof inputLength !== "number" || !Number.isSafeInteger(inputLength) || inputLength < 0 || typeof outputLength !== "number" || !Number.isSafeInteger(outputLength) || outputLength < 0 || !Array.isArray(controls) || controls.length > inputLength || inputLength + outputLength > request.input.length + controls.length) return request;
+	const previousInput = request.input.slice(0, inputLength - controls.length);
+	let lastIndex = -1;
+	for (const control of controls) {
+		if (!isRecord(control) || typeof control.index !== "number" || !Number.isSafeInteger(control.index) || control.index <= lastIndex || control.index > previousInput.length || !isConfigurationUpdate(control.item)) return request;
+		previousInput.splice(control.index, 0, control.item);
+		lastIndex = control.index;
+	}
+	const previous = {
+		...request,
+		reasoning: {
+			...request.reasoning,
+			effort
+		},
+		input: previousInput
+	};
+	if (responsesContinuationRequestFingerprint(previous) !== requestHash) return request;
+	const prepared = replayResponsesReasoningUpdates(previous, request, outputLength);
+	if (responsesContinuationPrefixFingerprint((prepared.input ?? []).slice(0, inputLength + outputLength)) !== prefixHash) return request;
+	return prepared;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-request-fetch.ts
+function withDefaultResponsesStreamEncoding(fetch) {
+	return (input, init) => {
+		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		if (headers.has("accept-encoding")) return fetch(input, init);
+		headers.set("accept-encoding", "identity");
+		return fetch(input, {
+			...init,
+			headers
+		});
+	};
+}
+/** Preserve the existing fetch policy while binding explicit continuation dispatch to its signal. */
+function createResponsesRequestFetch(model, options) {
+	const lifecycle = options.lifecycle;
+	if (lifecycle && options.compact) throw new Error("Provider review continuation cannot replace its reviewed input with compaction");
+	let fetchOverride = options.compact ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : options.stream ? withDefaultResponsesStreamEncoding(buildGuardedModelFetch(model, void 0, { onSseComment: options.onSseComment })) : void 0;
+	if (lifecycle) {
+		const dispatchFetch = fetchOverride ?? buildGuardedModelFetch(model);
+		fetchOverride = async (input, init) => {
+			const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+			await lifecycle.beforeDispatch(signal ?? void 0);
+			signal?.throwIfAborted();
+			lifecycle.assertCurrent();
+			return dispatchFetch(input, init);
+		};
+	}
+	return fetchOverride;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-steering.ts
+function cloneWireRequest(request) {
+	const serialized = JSON.stringify(request);
+	return JSON.parse(serialized);
+}
+async function projectResponsesSteeringInput(request, project) {
+	const { input: activeInput, ...activeSettings } = cloneWireRequest(request);
+	if (!Array.isArray(activeInput)) return [];
+	const { input, ...settings } = cloneWireRequest(await project());
+	if (!Array.isArray(input) || stableStringify(settings) !== stableStringify(activeSettings) || stableStringify(input.slice(0, activeInput.length)) !== stableStringify(activeInput)) return [];
+	const projected = input.slice(activeInput.length);
+	return projected.every((item) => isRecord(item) && item.role === "user") ? projected : [];
+}
+/** One response owns admission; accepted input stays on this connection until continuation. */
+function createResponsesSteering(params) {
+	let responseId;
+	let sealed = false;
+	let unsubscribe;
+	const pending = [];
+	const accepted = /* @__PURE__ */ new Map();
+	const acknowledged = /* @__PURE__ */ new Set();
+	const seal = () => {
+		sealed = true;
+		const cleanup = unsubscribe;
+		unsubscribe = void 0;
+		cleanup?.();
+	};
+	return {
+		get responseId() {
+			return responseId;
+		},
+		get pending() {
+			return pending.length > 0;
+		},
+		get acceptedInput() {
+			return [...accepted.values()].flat();
+		},
+		seal,
+		close(error) {
+			seal();
+			for (const submission of pending.splice(0)) submission.reject(error);
+		},
+		handle(event) {
+			if (!isRecord(event)) return false;
+			if (event.type === "response.created" && !responseId && !sealed) {
+				const response = isRecord(event.response) ? event.response : void 0;
+				if (typeof response?.id !== "string" || !response.id.trim()) throw new Error("Responses steering requires a response identity");
+				const activeResponseId = response.id;
+				responseId = activeResponseId;
+				const cleanup = params.onActiveResponse({
+					needsContinuation: params.needsContinuation,
+					steer(messages) {
+						if (sealed || messages.length === 0) return Promise.resolve(false);
+						params.assertActive();
+						const converted = params.toInput(messages);
+						const submit = (input) => {
+							if (sealed || input.length === 0) return Promise.resolve(false);
+							params.assertActive();
+							return new Promise((resolve, reject) => {
+								pending.push({
+									input,
+									resolve,
+									reject
+								});
+								params.send({
+									type: "response.steer",
+									previous_response_id: activeResponseId,
+									input
+								});
+							});
+						};
+						return Array.isArray(converted) ? submit(converted) : converted.then(submit);
+					}
+				});
+				if (sealed) cleanup?.();
+				else unsubscribe = cleanup;
+				return false;
+			}
+			if (event.type !== "response.steer.accepted" && event.type !== "response.steer.failed" && event.type !== "response.steer.pending") return false;
+			const steer = isRecord(event.steer) ? event.steer : void 0;
+			if (!responseId || steer?.previous_response_id !== responseId) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.failed" && steer.id === void 0) {
+				const index = pending.findIndex((submission) => stableStringify(submission.input) === stableStringify(steer.input));
+				const submission = pending[index];
+				if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+				pending.splice(index, 1);
+				submission.resolve(false);
+				return true;
+			}
+			if (typeof steer.id !== "string" || !steer.id.trim()) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.pending") {
+				if (!accepted.has(steer.id)) throw new Error("Responses steering pending event has no accepted submission");
+				return true;
+			}
+			if (event.type === "response.steer.failed" && accepted.has(steer.id)) throw new Error("OpenAI could not apply accepted steering; the queued message remains in the conversation");
+			if (acknowledged.has(steer.id)) throw new Error("Responses steering acknowledgement was already applied");
+			const submission = pending.shift();
+			if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+			acknowledged.add(steer.id);
+			if (event.type === "response.steer.accepted") {
+				accepted.set(steer.id, submission.input);
+				submission.resolve(true);
+			} else submission.resolve(false);
+			return true;
+		}
+	};
+}
+/** Accepted steering is prepended by the server, so never repeat it in response.create. */
+function omitAcceptedSteering(input, accepted) {
+	const remaining = [...input];
+	for (const message of accepted) {
+		const index = remaining.findIndex((item) => stableStringify(item) === stableStringify(message));
+		if (index < 0) throw new Error("Responses steering continuation no longer contains the accepted user input");
+		remaining.splice(index, 1);
+	}
+	return remaining;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-websocket-recovery.ts
+/** Owns safe WebSocket rejection recovery; transport selection and session leases stay with the caller. */
+function createRecoverableResponsesWebSocketStream(params) {
+	const { trackedWebSocketStream, websocket, websocketSignal, options, output, buildRequest, createSseStream, closeWebSocketForFallback, logWebSocketFallback, startStream } = params;
+	return { async *[Symbol.asyncIterator]() {
+		let acceptance = "pending";
+		let outputObserved = false;
+		try {
+			for await (const event of trackedWebSocketStream) {
+				const { failure, hasResponseOutput, isPrelude } = readResponsesRecoveryEvent(event);
+				outputObserved ||= hasResponseOutput;
+				if (isResponsesServiceTierRejection(failure) && !websocket.hasActiveResponse) throw new OpenAIResponsesWebSocketSafeRetryError("invalid_request_error", void 0, "service_tier", "Invalid service_tier argument", failure);
+				outputObserved ||= !isPrelude;
+				if (acceptance === "pending") {
+					acceptance = "observing";
+					await notifyProviderStreamOpened({
+						options,
+						cancelStream: () => websocket.finish({ keep: false })
+					});
+					acceptance = "accepted";
+				}
+				startStream();
+				yield event;
+			}
+		} catch (error) {
+			if (error instanceof OpenAIResponsesWebSocketSafeRetryError) {
+				if (isResponsesServiceTierRejection(error)) {
+					const nextTier = nextResponsesServiceTier(websocket.request.service_tier, error);
+					if (!nextTier || outputObserved || acceptance === "observing" || output.content.length || websocketSignal.aborted || websocket.hasActiveResponse) throw error;
+					closeWebSocketForFallback("service_tier_rejected");
+					const rejectedTier = websocket.request.service_tier;
+					if (rejectedTier === "ultrafast" || rejectedTier === "priority") responsesServiceTierObserver.reject(options, rejectedTier);
+					yield* await createSseStream({
+						...await buildRequest("full-history"),
+						service_tier: nextTier
+					});
+					return;
+				}
+				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;
+			params.setTransportToSse();
+			logWebSocketFallback("before_first_event");
+			yield* await createSseStream();
+		}
+	} };
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-websocket.ts
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
+const WEBSOCKET_OPEN_STATE = 1;
+const websocketSessionCache = /* @__PURE__ */ new Map();
+const degradedWebSocketConnections = /* @__PURE__ */ new Map();
+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);
+	entry.steeringContinuation?.steering.close(/* @__PURE__ */ new Error("Responses steering connection closed"));
+	entry.steeringContinuation?.iterator.return?.().catch(() => void 0);
+	entry.steeringContinuation = void 0;
+	if (websocketSessionCache.get(cacheKey) === entry) websocketSessionCache.delete(cacheKey);
+}
+function scheduleSessionWebSocketExpiry(cacheKey, entry) {
+	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 owner = getAiTransportHost();
+	const resolvedApiKey = owner.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,
+		owner,
+		ownerId: getSessionResourceOwnerId(owner),
+		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;
+	const steeringContinuation = entry.steeringContinuation;
+	entry.steeringContinuation = void 0;
+	return {
+		socket: entry.socket,
+		iterator: steeringContinuation?.iterator ?? entry.socket.stream(),
+		entry,
+		reusedConnection,
+		steeringContinuation,
+		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" || !params.sessionId) return createTransientWebSocketLease(connection);
+	const cacheKey = `${connection.ownerId}\0${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,
+		owner: connection.owner,
+		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?.aborted) throw transportAbortError(signal);
+	return await racePromiseWithAbortSignal(iterator.next(), signal, transportAbortError);
+}
+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);
+	let fullRequest = sanitizeWebSocketRequest(params.request);
+	const requestModel = typeof fullRequest.model === "string" ? fullRequest.model : "";
+	const degradationKey = `${connection.ownerId}\0${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"));
+	if (degraded) clearTimeout(degraded.expiryTimer);
+	degradedWebSocketConnections.delete(degradationKey);
+	const markDegraded = () => {
+		const cooldownMs = params.degradeCooldownMs;
+		if (cooldownMs === void 0 || !Number.isFinite(cooldownMs) || cooldownMs <= 0) return;
+		const entry = {
+			sessionId: params.sessionId,
+			owner: connection.owner,
+			retryAt: Date.now() + cooldownMs,
+			expiryTimer: setTimeout(() => {
+				if (degradedWebSocketConnections.get(degradationKey) === entry) degradedWebSocketConnections.delete(degradationKey);
+			}, cooldownMs)
+		};
+		entry.expiryTimer.unref?.();
+		degradedWebSocketConnections.set(degradationKey, entry);
+	};
+	let lease;
+	try {
+		lease = acquireWebSocket(params, connection);
+	} catch (error) {
+		markDegraded();
+		throw new OpenAIResponsesWebSocketPreDispatchError(error);
+	}
+	let prepared;
+	let previousContinuation;
+	const resumedSteering = lease.steeringContinuation;
+	const steeringMode = resumedSteering ? resumedSteering.requiresInput ? "required-input" : "automatic" : void 0;
+	try {
+		const continuation = previousContinuation = lease.entry?.continuation;
+		if (continuation && lease.entry) {
+			lease.entry.continuation = void 0;
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
+		} else {
+			fullRequest = params.restoreRequest?.(fullRequest) ?? fullRequest;
+			prepared = {
+				request: fullRequest,
+				continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
+			};
+		}
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw error;
+	}
+	let streamStarted = false;
+	let terminalResponse;
+	let terminalReceived = false;
+	let released = false;
+	let retainIterator = false;
+	let deferredInput = false;
+	let inputReplay;
+	if (resumedSteering) try {
+		if (prepared.continuationStatus !== "continued" || !prepared.request.previous_response_id) throw new Error("Responses steering continuation changed its request or history");
+		const input = omitAcceptedSteering(prepared.request.input ?? [], resumedSteering.acceptedInput);
+		if (!resumedSteering.requiresInput && (stableStringify(fullRequest.instructions) !== stableStringify(resumedSteering.instructions) || stableStringify(fullRequest.tools) !== stableStringify(resumedSteering.tools))) throw new Error("Responses automatic steering continuation cannot change instructions or tools");
+		const baseline = prepared.fullRequest ?? fullRequest;
+		const priorLength = (baseline.input?.length ?? 0) - (prepared.request.input?.length ?? 0);
+		const fingerprints = input.map(responsesInputFingerprint);
+		if (fingerprints.length > 0) inputReplay = {
+			afterResponseId: prepared.request.previous_response_id,
+			before: resumedSteering.requiresInput ? fingerprints : [],
+			after: resumedSteering.requiresInput ? [] : fingerprints
+		};
+		const delivered = resumedSteering.requiresInput ? input : [];
+		prepared.fullRequest = {
+			...baseline,
+			input: [
+				...(baseline.input ?? []).slice(0, priorLength),
+				...resumedSteering.acceptedInput,
+				...delivered
+			]
+		};
+		prepared.request = {
+			...prepared.request,
+			input: delivered
+		};
+		deferredInput = !resumedSteering.requiresInput && input.length > 0;
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw new OpenAIResponsesWebSocketPostDispatchError(error);
+	}
+	const steering = lease.entry && params.onActiveResponse && params.steeringInput ? createResponsesSteering({
+		onActiveResponse: params.onActiveResponse,
+		toInput: params.steeringInput,
+		send: (event) => lease.socket.sendRaw(JSON.stringify(event)),
+		needsContinuation: () => deferredInput,
+		assertActive: () => {
+			if (released || terminalReceived || params.signal?.aborted) throw new Error("Responses steering is no longer active");
+		}
+	}) : void 0;
+	const finish = ({ keep = true } = {}) => {
+		if (released) return;
+		released = true;
+		if (keep && lease.entry && terminalResponse) lease.entry.continuation = recordResponsesContinuationState(previousContinuation, prepared.fullRequest ?? fullRequest, terminalResponse, previousContinuation?.lastResponseId === prepared.request.previous_response_id);
+		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);
+				if (resumedSteering) {
+					requestDispatched = true;
+					if (resumedSteering.requiresInput) lease.socket.send({
+						...prepared.request,
+						type: "response.create"
+					});
+				}
+				for (;;) {
+					const buffered = resumedSteering?.buffered.shift();
+					const next = buffered ? {
+						value: buffered,
+						done: false
+					} : await nextWebSocketMessage(iterator, params.signal);
+					if (next.done) throw new Error("OpenAI Responses WebSocket closed before a terminal response event");
+					if (next.value.type === "open") {
+						if (!requestDispatched) {
+							requestDispatched = true;
+							lease.socket.send({
+								...prepared.request,
+								type: "response.create"
+							});
+						}
+						continue;
+					}
+					const event = readServerEvent(next.value);
+					if (!event) continue;
+					if (isRecord(event) && typeof event.type === "string" && event.type.startsWith("response.steer.")) {
+						if ((isRecord(event.steer) && event.steer.previous_response_id === steering?.responseId ? steering : resumedSteering?.steering ?? steering)?.handle(event)) continue;
+					}
+					steering?.handle(event);
+					if (event.type === "response.completed") terminalResponse = event.response;
+					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
+					if (terminalReceived) {
+						steering?.seal();
+						if (event.type === "response.failed") steering?.close(/* @__PURE__ */ new Error("Responses failed before steering could be applied"));
+						const continuationBuffer = [];
+						for (;;) {
+							if (!steering?.pending) break;
+							const acknowledgement = await nextWebSocketMessage(iterator, params.signal);
+							if (acknowledgement.done) throw new Error("Responses closed before acknowledging steering");
+							const acknowledgedEvent = readServerEvent(acknowledgement.value);
+							if (!steering.handle(acknowledgedEvent)) continuationBuffer.push(acknowledgement.value);
+						}
+						const acceptedInput = steering?.acceptedInput ?? [];
+						const isSteered = event.type === "response.incomplete" && isRecord(event.response.incomplete_details) && event.response.incomplete_details.reason === "steered";
+						if (lease.entry && steering && acceptedInput.length > 0 && (event.type === "response.completed" || isSteered)) {
+							if (event.type === "response.incomplete") terminalResponse = event.response;
+							lease.entry.steeringContinuation = {
+								iterator,
+								buffered: continuationBuffer,
+								acceptedInput,
+								requiresInput: (terminalResponse?.output ?? []).some((item) => (item.type === "function_call" || item.type === "custom_tool_call") && !(isRecord(item) && item.async === true) || item.type === "mcp_approval_request"),
+								steering,
+								instructions: fullRequest.instructions,
+								tools: fullRequest.tools
+							};
+							retainIterator = true;
+							if (isSteered) {
+								yield {
+									...event,
+									type: "response.completed",
+									response: {
+										...event.response,
+										status: "completed",
+										incomplete_details: null
+									}
+								};
+								return;
+							}
+						}
+					}
+					yield event;
+					if (terminalReceived) {
+						degradedWebSocketConnections.delete(degradationKey);
+						return;
+					}
+				}
+			} catch (error) {
+				const steeringDispatched = Boolean(steering?.pending || steering?.acceptedInput.length || resumedSteering);
+				steering?.close(error instanceof Error ? error : /* @__PURE__ */ new Error("Responses steering failed"));
+				if (lease.entry) lease.entry.continuation = void 0;
+				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError && !steeringDispatched;
+				if (!params.callerSignal?.aborted && !safeRetry) markDegraded();
+				if (!requestDispatched && !params.signal?.aborted) throw new OpenAIResponsesWebSocketPreDispatchError(error);
+				if (!requestDispatched || params.callerSignal?.aborted || safeRetry) throw error;
+				throw new OpenAIResponsesWebSocketPostDispatchError(error);
+			} finally {
+				steering?.seal();
+				if (!retainIterator) {
+					steering?.close(/* @__PURE__ */ new Error("Responses stream ended before steering was confirmed"));
+					await iterator.return?.().catch(() => void 0);
+				}
+				if (!terminalReceived) finish({ keep: false });
+			}
+		} },
+		request: prepared.request,
+		fullRequest: prepared.fullRequest ?? fullRequest,
+		reusedConnection: lease.reusedConnection,
+		continuationStatus: prepared.continuationStatus,
+		inputReplay,
+		get hasActiveResponse() {
+			return Boolean(steering?.responseId || resumedSteering);
+		},
+		finish
+	};
+}
+function closeOpenAIResponsesWebSocketSessions(sessionId, owner) {
+	for (const [cacheKey, entry] of websocketSessionCache) {
+		if (owner && entry.owner !== owner || sessionId && entry.sessionId !== sessionId) continue;
+		invalidateOwnedWebSocketSession(cacheKey, entry, "session_cleanup");
+	}
+	for (const [key, entry] of degradedWebSocketConnections) if ((!owner || entry.owner === owner) && (!sessionId || entry.sessionId === sessionId)) {
+		clearTimeout(entry.expiryTimer);
+		degradedWebSocketConnections.delete(key);
+	}
+}
+registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
+//#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(model) ? 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 createOpenAIResponsesClient(model, apiKey, defaultHeaders, fetchOverride) {
+	return new OpenAI({
+		apiKey,
+		baseURL: resolveOpenAIClientBaseUrl(model),
+		dangerouslyAllowBrowser: true,
+		defaultHeaders,
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	});
+}
+function createResponsesTransportExecutor(config) {
+	return (model, context, options) => {
+		const responsesOptions = options;
+		const compactRequest = claimResponsesCompactRequest(responsesOptions);
+		const { eventStream, stream } = createWritableTransportEventStream();
+		(async () => {
+			const output = createAssistantOutput(model, config.outputApi);
+			let firstEventAbort;
+			let continuationClaim;
+			const requestLifecycle = responsesRequestLifecycle.get(options);
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const websocketMode = resolveNativeOpenAIResponsesWebSocketMode(model, responsesOptions?.transport);
+				const encodeBody = prepareModelRequestBody(websocketMode || compactRequest ? void 0 : options);
+				const turnState = resolveProviderTransportTurnState(model, {
+					sessionId: options?.sessionId,
+					turnId: randomUUID(),
+					attempt: 1,
+					transport: websocketMode ? "websocket" : "stream"
+				});
+				const websocketSessionPolicy = websocketMode ? turnState?.websocket : void 0;
+				const httpTurnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
+				const websocketTurnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, websocketSessionPolicy?.headers);
+				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketTurnHeaders, options?.sessionId, options?.cacheRetention) : void 0;
+				const httpHeaders = buildOpenAIClientHeaders(model, context, options?.headers, httpTurnHeaders, options?.sessionId, options?.cacheRetention);
+				const fetchOverride = createResponsesRequestFetch(model, {
+					compact: Boolean(compactRequest),
+					stream: config.streamRequest,
+					lifecycle: requestLifecycle,
+					onSseComment: () => notifyLlmRequestActivity(options?.signal, false)
+				});
+				const client = config.createClient(model, apiKey, httpHeaders, fetchOverride);
+				const nativeAstra = model.id === "gpt-6-astra" && supportsNativeOpenAIResponsesEndpoint(model);
+				const asyncToolExecutionEligible = nativeAstra && options?.asyncToolExecution === true && !responsesOptions?.openclawCodeModeToolSurface;
+				const prepareRequest = async (request) => {
+					let params = request;
+					const nextParams = await options?.onPayload?.(params, model);
+					if (nextParams !== void 0) params = nextParams;
+					params = sanitizeOpenAICodexResponsesParams(model, params);
+					params = sanitizeResponsesImagePayload(params);
+					if (responsesOptions?.openclawCodeModeToolSurface === true) {
+						const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
+						const allowedHostedToolTypes = responsesOptions?.openclawCodeModeAllowedHostedToolTypes;
+						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
+						assertCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
+					}
+					if (asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true && params.tools) {
+						const synchronousTools = new Set(context.tools?.flatMap((tool) => tool.async === false ? [tool.name] : []));
+						params.tools = params.tools.map((tool) => tool.type === "function" && !synchronousTools.has(tool.name) ? {
+							...tool,
+							async: true
+						} : tool);
+					}
+					return params;
+				};
+				const buildRequest = (replayMode, requestContext = context) => prepareRequest(config.buildRequest(model, requestContext, responsesOptions, turnState?.metadata, replayMode));
+				let params = await buildRequest("checkpoint");
+				const asyncTools = asyncToolExecutionEligible && params.model === "gpt-6-astra" && params.multi_agent?.enabled !== true;
+				if (compactRequest) {
+					const compacted = await postOpenAIResponsesCompaction({
+						client,
+						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(model) || resolveOpenAIResponsesPayloadPolicy(model).explicitContinuationOptIn) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
+					continuationClaim = claimOpenAIResponsesHttpContinuation({
+						sessionId,
+						apiKey,
+						baseUrl: model.baseUrl,
+						headers: httpHeaders,
+						request: params,
+						restoreRequest: () => restoreResponsesReasoningState(context, model, responsesOptions, params)
+					});
+					if (continuationClaim) params = continuationClaim.fullRequest;
+				}
+				const observePrompt = createResponsesPromptEgressObserver(responsesOptions, context.systemPrompt);
+				const requestStartedAt = Date.now();
+				let started = false;
+				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
+				});
+				const websocketSignal = combineWebSocketTimeoutSignal(firstEvent.signal, model, requestOptions?.timeout);
+				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} requestIdHash=${redactIdentifier(options?.requestId, { len: 64 })} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
+				const responseModelTracker = createResponseModelTracker(isOpenAICodexResponsesModel(model));
+				let continuationBaseline;
+				let dispatchedPreviousResponseId;
+				let contextUsageEligible = true;
+				let requestedTier;
+				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
+					const { stream: responseStream } = await createResponsesStreamWithRecovery({
+						client,
+						request: initialRequest,
+						requestOptions,
+						model,
+						encodeBody,
+						observePrompt,
+						initialAttemptKind,
+						initialRejectedCompaction,
+						buildFullHistoryRequest: () => buildRequest("full-history"),
+						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint),
+						canRetryStream: () => output.content.length === 0,
+						onServiceTierRejected: (tier) => responsesServiceTierObserver.reject(options, tier),
+						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
+							requestedTier = attempt.request.service_tier;
+							contextUsageEligible &&= attempt.kind === "initial";
+							dispatchedPreviousResponseId = attempt.request.previous_response_id;
+							continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
+							const trackedResponseStream = responseModelTracker.track(response, rawResponseStream);
+							return withProviderResponseHook({
+								stream: observeResponsesStream(trackedResponseStream, 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();
+								}
+							});
+						}
+					});
+					return responseStream;
+				};
+				let responseStream;
+				let websocketBaseline;
+				let finishWebSocket;
+				let transport = "sse";
+				const logWebSocketFallback = (reason) => emitModelTransportDebug(log, `[responses] websocket_fallback provider=${model.provider} api=${model.api} model=${model.id} reason=${reason}`);
+				const closeWebSocketForFallback = (reason) => {
+					finishWebSocket?.({ keep: false });
+					finishWebSocket = void 0;
+					transport = "sse";
+					logWebSocketFallback(reason);
+				};
+				if (websocketMode) try {
+					const websocket = createOpenAIResponsesWebSocketStream({
+						client,
+						request: params,
+						restoreRequest: (request) => restoreResponsesReasoningState(context, model, responsesOptions, request),
+						mode: websocketMode,
+						sessionId: options?.sessionId,
+						headers: websocketHeaders,
+						signal: websocketSignal,
+						callerSignal: options?.signal,
+						degradeCooldownMs: websocketSessionPolicy?.degradeCooldownMs,
+						onActiveResponse: nativeAstra && params.model === "gpt-6-astra" ? options?.onActiveResponse : void 0,
+						steeringInput: (messages) => {
+							contextUsageEligible = false;
+							return projectResponsesSteeringInput(params, () => buildRequest("checkpoint", {
+								...context,
+								messages: [...context.messages, ...messages]
+							}));
+						}
+					});
+					finishWebSocket = websocket.finish;
+					requestedTier = websocket.request.service_tier;
+					websocketBaseline = websocket.fullRequest;
+					recordResponsesInputReplay(output, websocket.inputReplay);
+					contextUsageEligible &&= websocket.inputReplay === void 0;
+					observePrompt?.(websocket.request, {
+						egress: "responses-websocket",
+						payloadVariant: "initial"
+					});
+					transport = "websocket";
+					emitModelTransportDebug(log, `[responses] websocket_selected provider=${model.provider} api=${model.api} model=${model.id} mode=${websocketMode} reused=${websocket.reusedConnection} continuation=${websocket.continuationStatus === "continued"} continuationStatus=${websocket.continuationStatus} sessionIdHash=${redactIdentifier(options?.sessionId)} headersHash=${redactIdentifier(JSON.stringify(Object.entries(websocketHeaders ?? {}).toSorted(([a], [b]) => a.localeCompare(b))))}`);
+					responseStream = createRecoverableResponsesWebSocketStream({
+						trackedWebSocketStream: responseModelTracker.track(void 0, websocket.stream),
+						websocket,
+						websocketSignal,
+						options,
+						output,
+						buildRequest,
+						createSseStream,
+						closeWebSocketForFallback,
+						logWebSocketFallback,
+						startStream,
+						setTransportToSse: () => {
+							transport = "sse";
+						}
+					});
+				} catch (error) {
+					if (error instanceof OpenAIResponsesWebSocketPostDispatchError) throw error;
+					closeWebSocketForFallback("setup_failure");
+					responseStream = await createSseStream();
+				}
+				else responseStream = await createSseStream();
+				try {
+					const acceptedResponseStream = withResponsesRequestAcceptance(responseStream, requestLifecycle, transport === "websocket" ? websocketSignal : firstEvent.signal);
+					const terminal = await processResponsesStream(acceptedResponseStream, output, stream, model, {
+						canRetryIdentityConflict: () => hasOnlyResponsesFunctionTools(transport === "websocket" ? websocketBaseline : continuationBaseline),
+						...config.pricingOptions?.(responsesOptions, model),
+						resolveServiceTier: (responseTier, originalTier) => responseTier ?? (requestedTier === "priority" || requestedTier === "default" ? requestedTier : originalTier),
+						onServiceTier: (responseTier) => responsesServiceTierObserver.observe(options, requestedTier, responseTier),
+						firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
+						abortFirstEventStream: firstEvent.abort,
+						onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+						signal: options?.signal,
+						reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+							authProfileId: responsesOptions?.authProfileId,
+							sessionId: options?.sessionId
+						}),
+						asyncToolExecution: asyncTools,
+						...responseModelTracker.terminalOptions
+					});
+					finishWebSocket?.();
+					if (options?.signal?.aborted) throw transportAbortError(options.signal);
+					if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+					const admitted = transport === "websocket" ? websocketBaseline : continuationBaseline;
+					if (terminal && admitted && supportsNativeOpenAIResponsesEndpoint(model)) recordResponsesReasoningState(output, model, responsesOptions, admitted, terminal.output);
+					if (continuationClaim && continuationBaseline && terminal) continuationClaim.commit(continuationBaseline, terminal, dispatchedPreviousResponseId);
+					if (terminal && admitted && contextUsageEligible) recordResponsesContextUsage(output, model, responsesOptions, admitted, terminal.output, "transport");
+				} 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
+				});
+			} catch (error) {
+				if (requestLifecycle) await requestLifecycle.settle().catch(() => void 0);
+				if (compactRequest) {
+					compactRequest.reject(error);
+					failTransportStream({
+						stream,
+						output,
+						signal: options?.signal,
+						error
+					});
+					return;
+				}
+				if (error instanceof ResponsesStreamFailure && error.observation) logResponsesFailedNoDetails(error.observation);
+				const incompleteReason = output.diagnostics?.find(({ type }) => type === "openai_responses_terminal")?.details?.incompleteReason;
+				emitModelTransportError(log, "responses", `provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error) + (typeof incompleteReason === "string" ? ` incompleteReason=${incompleteReason}` : ""), options?.signal);
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error
+				});
+			} finally {
+				continuationClaim?.release();
+				firstEventAbort?.dispose();
+			}
+		})();
+		return eventStream;
+	};
+}
+function createOpenAIResponsesTransportStreamFn() {
+	return createResponsesTransportExecutor({
+		streamRequest: true,
+		httpContinuation: true,
+		createClient: createOpenAIResponsesClient,
+		buildRequest: buildOpenAIResponsesParams,
+		pricingOptions: (options, model) => ({
+			serviceTier: options?.serviceTier,
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
+		})
+	});
+}
+function createAzureOpenAIResponsesTransportStreamFn() {
+	return createResponsesTransportExecutor({
+		outputApi: "azure-openai-responses",
+		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
+		createClient: createAzureOpenAIClient,
+		buildRequest: (model, context, options, metadata, replayMode) => {
+			const deploymentName = resolveAzureDeploymentNameFromMap({
+				modelId: model.id,
+				deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
+			});
+			const params = buildOpenAIResponsesParams(model, context, options, metadata, replayMode);
+			params.model = deploymentName;
+			delete params.store;
+			return params;
+		}
+	});
+}
+function createAzureOpenAIClient(model, apiKey, defaultHeaders, fetchOverride) {
+	const baseURL = model.baseUrl.replace(/\/+$/, "");
+	const clientOptions = {
+		apiKey,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders,
+		baseURL,
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	};
+	if (isOpenAICompatibleAzureResponsesBaseUrl(baseURL)) return new OpenAI(clientOptions);
+	return new AzureOpenAI({
+		...clientOptions,
+		apiVersion: resolveAzureOpenAIApiVersion()
+	});
 }
 //#endregion
 //#region packages/ai/src/transports/openai-completions-transport.ts
@@ -2010,7 +3122,23 @@ function createDirectCompletionsEventStream(output, stream) {
 	};
 }
 function createOpenAICompletionsTransportStreamFn() {
-	return (model, context, options) => streamOpenAICompletionsRequest(model, context, options, "managed");
+	const streamResponses = createOpenAIResponsesTransportStreamFn();
+	return (model, context, options) => {
+		const completionsOptions = options;
+		if (model.reasoning && context.tools?.length && supportsModelTools(model) && isNativeOpenAIEndpoint(model)) {
+			const toolChoice = completionsOptions?.toolChoice;
+			const responsesOptions = {
+				...options,
+				...completionsOptions?.reasoning === void 0 && completionsOptions?.reasoningEffort === void 0 ? { reasoningEffort: "high" } : {},
+				...toolChoice && typeof toolChoice === "object" ? { toolChoice: toOpenAIResponsesToolChoice(toolChoice) } : {}
+			};
+			return streamResponses(getAiTransportHost().inheritManagedTransport(model, {
+				...model,
+				api: "openai-responses"
+			}), context, responsesOptions);
+		}
+		return streamOpenAICompletionsRequest(model, context, completionsOptions, "managed");
+	};
 }
 function streamOpenAICompletionsRequest(model, context, options, mode) {
 	const { eventStream, stream } = createWritableTransportEventStream();
@@ -2054,9 +3182,21 @@ function streamOpenAICompletionsRequest(model, context, options, mode) {
 				...buildOpenAISdkRequestOptions(model, firstEventAbort.signal, { timeoutMs: options?.timeoutMs }),
 				...await encodeBody(params)
 			};
-			const { data: responseStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
+			const request = client.chat.completions.create(params, requestOptions);
+			const response = await request.asResponse();
 			const hookedResponseStream = withProviderResponseHook({
-				stream: responseStream,
+				stream: { async *[Symbol.asyncIterator]() {
+					if (!params.stream) {
+						yield await boundResponseBody(response, {
+							maxBytes: 16777216,
+							onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`Chat Completions JSON response exceeds ${maxBytes} bytes`)
+						}).json();
+						return;
+					}
+					const data = await request;
+					if (Symbol.asyncIterator in data) yield* data;
+					else yield data;
+				} },
 				signal: firstEventAbort.signal,
 				abort: firstEventAbort.abort,
 				hook: createOpenAIProviderAcceptanceHook(options, response, model),
@@ -2102,7 +3242,6 @@ function streamOpenAICompletionsRequest(model, context, options, mode) {
 				signal: options?.signal,
 				error,
 				cleanup: () => {
-					if (mode === "managed") output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 					finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
 					clearPendingCommentaryText(provisionalCommentaryTags);
 					tagUnresolvedTextAsCommentary(output);
@@ -2143,7 +3282,7 @@ function createManagedCompletionsClient(model, context, options, apiKey, cacheRe
 	const optionHeaders = resolveOpencodeSessionHeaders(model, options);
 	const turnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
 	const doneDetector = createSseDoneDetector();
-	const baseFetch = buildGuardedModelFetch(model);
+	const baseFetch = buildGuardedModelFetch(model, void 0, { onSseComment: () => notifyLlmRequestActivity(options?.signal, false) });
 	const doneDetectingFetch = async (url, init) => {
 		const response = await baseFetch(url, init);
 		if (!response.body || !response.ok) return response;
@@ -2157,11 +3296,7 @@ function createManagedCompletionsClient(model, context, options, apiKey, cacheRe
 				doneDetector.finish();
 			}
 		}));
-		return new Response(transformed, {
-			headers: response.headers,
-			status: response.status,
-			statusText: response.statusText
-		});
+		return new Response(transformed, response);
 	};
 	const clientConfig = buildOpenAICompletionsClientConfig(model, buildOpenAIClientHeaders(model, context, {
 		...turnHeaders,
@@ -2181,4 +3316,4 @@ function createManagedCompletionsClient(model, context, options, apiKey, cacheRe
 	};
 }
 //#endregion
-export { flattenCompletionMessagesToStringContent as a, hasOpenAICompatibleConversationTurn as c, createDeepSeekTextFilter as d, convertMessages as i, canonicalizeMaxTokensParam as l, streamOpenAICompletionsRequest as n, stripCompletionMessagesToRoleContent as o, buildOpenAICompletionsParams as r, applyCompletionsAnthropicCacheControl as s, createOpenAICompletionsTransportStreamFn as t, resolveMaxTokensParam as u };
+export { requestPreparedOpenAIResponsesCompaction as a, convertMessages as c, applyCompletionsAnthropicCacheControl as d, hasOpenAICompatibleConversationTurn as f, createDeepSeekTextFilter as h, createOpenAIResponsesTransportStreamFn as i, flattenCompletionMessagesToStringContent as l, resolveMaxTokensParam as m, streamOpenAICompletionsRequest as n, hasResponsesWebSearchTool as o, canonicalizeMaxTokensParam as p, createAzureOpenAIResponsesTransportStreamFn as r, buildOpenAICompletionsParams as s, createOpenAICompletionsTransportStreamFn as t, stripCompletionMessagesToRoleContent as u };