@openclaw/ai 2026.10.3 → 2026.10.4

package/dist/{openai-completions-transport-D_ZhLzh_.mjs → openai-completions-transport-QYABn8Uz.mjs}

@@ -3,33 +3,39 @@ import { r as appendAssistantThinking } from "./event-stream-C5AbCAaZ.mjs";
 import { o as isRecord } 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-u3o8XiAp.mjs";
-import { _ as isOpenAIGpt54MiniModel, v as isOpenAIGpt55Model, y as isOpenAIGpt56Model } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { N as isImageWithMediaPayload, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-u3o8XiAp.mjs";
+import { A as resolveOpenAIThinkingApi, D as supportsOpenAITemperature, _ as isOpenAIGpt54MiniModel, b as isOpenAIGpt6Model, d as OpenAIResponsesWebSocketSafeRetryError, g as responsesServiceTierObserver, 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 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 { n as getSessionResourceOwnerId, r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
+import { o as truncateUtf16Safe, s as stableStringify } from "./provider-error-DQBE1bUQ.mjs";
 import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-BK6E2g4Q.mjs";
-import { r as emitModelTransportDebug } from "./diagnostics-Caj-4RBA.mjs";
-import { c as supportsModelTools, r as estimateStringChars } from "./text-signature-D_vRrx-z.mjs";
-import { i as resolveOpenAICompletionsCompat, l as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-GMN8A0fm.mjs";
+import { r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl, u as hasOnlyResponsesFunctionTools } from "./diagnostics-Caj-4RBA.mjs";
+import { d as supportsModelTools, i as providerReplayContextMatches, n as buildProviderReplayContext, o as estimateStringChars, r as isProviderReplayContext } from "./text-signature-CbqxIB8B.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-GMN8A0fm.mjs";
 import { i as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-BwhNNGQR.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-CCR7hSW0.mjs";
+import { E as createToolArgumentPreviewSchedule, M as racePromiseWithAbortSignal, O as parseStreamingJson, P as sanitizeSurrogates, S as withProviderResponseHook, _ as sanitizeNonEmptyTransportPayloadText, 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-CCR7hSW0.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-7QuSKriJ.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-D7JMUPjf.mjs";
+import { $ as supportsResponsesReasoningUpdate, A as recordResponsesContextUsage, At as parseOpenAICompletionsUsage, B as claimOpenAIResponsesHttpContinuation, C as resolveAzureOpenAIApiVersion, Ct as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, D as safeDebugValue, Dt as isOpenAICompletionsThinkingEnabled, E as logResponsesFailedNoDetails, Et as createResponseModelTracker, F as convertResponsesMessages, Ft as redactIdentifier, H as resolveResponsesContinuationRequest, It as sha256Hex, L as readResponsesInputReplayState, Mt as readOpenAICompletionsReasoningBatch, N as buildResponsesInputMessage, Nt as resolveOpenAIClientBaseUrl, O as summarizeOpenAITransportError, Ot as log, Pt as resolvePromptCacheKey, Q as replayResponsesReasoningUpdates, R as recordResponsesInputReplay, S as isInvalidEncryptedContentError, St as toOpenAIResponsesToolChoice, T as ResponsesStreamFailure, U as responsesContinuationPrefixFingerprint, V as recordResponsesContinuationState, W as responsesContinuationRequestFingerprint, Z as isConfigurationUpdate, a as prepareResponsesTools, at as assertCodeModeResponsesToolSurface, bt as reconcileOpenAICompletionsToolChoice, c as observeResponsesStream, ct as buildOpenAISdkRequestOptions, dt as getCompat, gt as resolveOpenAISimpleReasoningEffort, ht as resolveOpenAIRequestReasoning, it as suppressOpenAIResponsesCompaction, jt as readOpenAICompletionsContentDeltas, k as summarizeResponsesPayload, kt as measureUtf8AppendBytes, lt as enforceCodeModeResponsesToolSurface, mt as resolveOpenAIStrictToolFlagWithDiagnostics, n as applyResponsesServiceTierPricing, ot as buildOpenAIClientHeaders, pt as resolveCodeModeResponsesVisibleToolNames, s as processResponsesStream, st as buildOpenAISdkClientOptions, tt as buildOpenAIResponsesReasoningReplayMetadata, vt as prepareOpenAITools, w as resolveNextResponsesEncryptedContentAttempt, wt as createOpenAIProviderAcceptanceHook, x as createResponsesStreamWithEncryptedContentRetry, xt as reconcileOpenAIResponsesToolChoice, yt as projectOpenAITools, z as responsesInputFingerprint } from "./openai-responses-shared-BMx2NAS-.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
 import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-D5762GPH.mjs";
-import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-DVZOxbuR.mjs";
+import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-DzvV7Oso.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-D8f_oxHj.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-BX6TfCyW.mjs";
+import { i as createOpenAIProviderClient, n as resolveProviderSimpleCompletionHeaders, r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-1T3vwTvn.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-BIrI0mrA.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 { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-D0dvJMbZ.mjs";
+import { a as applyOpenAIResponsesPayloadPolicy, i as sanitizeResponsesImagePayload, n as isOpenAIResponsesCompactionOutput, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch } from "./openai-responses-compaction-window-tA4QkU0o.mjs";
+import { n as supportsNativeOpenAIResponsesEndpoint, t as isOfficialOpenAIResponsesBaseUrl } from "./openai-responses-endpoint-TV0y50fb.mjs";
+import { n as withResponsesRequestAcceptance, r as createResponsesPromptEgressObserver, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-Dskvtz_Z.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 = [
 	"|",
@@ -1883,6 +1889,1141 @@ function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
 	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 supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	const role = model.reasoning && supportsDeveloperRole !== false ? "developer" : "system";
+	return buildResponsesInputMessage(role, [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(messages, context) {
+	if (messages.length > 0 || !context.systemPrompt) return;
+	if (!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 instructions = typeof params.request.instructions === "string" && params.request.instructions.length > 0 ? params.request.instructions : void 0;
+	const body = instructions && !supportsNativeOpenAIResponsesEndpoint(params.model) ? {
+		model: params.request.model,
+		input: [buildOpenAIResponsesCompactSystemMessage(params.model, instructions), ...params.request.input ?? []]
+	} : {
+		model: params.request.model,
+		input: params.request.input,
+		...instructions ? { instructions } : {}
+	};
+	const response = await params.client.post("/responses/compact", {
+		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, { timeoutMs: params.options?.timeoutMs }),
+		body
+	});
+	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;
+	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.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" && Boolean(params.sessionId)) || !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,
+		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
+				});
+				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) params.tools = params.tools.map((tool) => tool.type === "function" ? {
+						...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 createResponsesStreamWithEncryptedContentRetry({
+						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,
+						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))))}`);
+					const trackedWebSocketStream = responseModelTracker.track(void 0, websocket.stream);
+					responseStream = { async *[Symbol.asyncIterator]() {
+						let providerAccepted = false;
+						try {
+							for await (const event of trackedWebSocketStream) {
+								if (!providerAccepted) {
+									providerAccepted = true;
+									await notifyProviderStreamOpened({
+										options,
+										cancelStream: () => websocket.finish({ keep: false })
+									});
+								}
+								startStream();
+								yield event;
+							}
+						} catch (error) {
+							if (error instanceof OpenAIResponsesWebSocketSafeRetryError) {
+								const encryptedContentRejected = isInvalidEncryptedContentError(error);
+								const recovery = encryptedContentRejected ? await resolveNextResponsesEncryptedContentAttempt({
+									kind: "initial",
+									request: {
+										...websocket.request,
+										stream: true
+									}
+								}, error, { buildFullHistoryRequest: () => buildRequest("full-history") }) : void 0;
+								if (encryptedContentRejected && !recovery) throw error;
+								closeWebSocketForFallback(`safe_server_error code=${error.code} status=${safeDebugValue(error.status)} param=${safeDebugValue(error.param)}`);
+								yield* await createSseStream(recovery?.request ?? await buildRequest("full-history"), recovery?.kind ?? "continuation-rejected", recovery?.rejectedCompaction);
+								return;
+							}
+							if (websocketSignal.aborted || !(error instanceof OpenAIResponsesWebSocketPreDispatchError)) throw error;
+							transport = "sse";
+							logWebSocketFallback("before_first_event");
+							yield* await createSseStream();
+						}
+					} };
+				} catch (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),
+						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;
+				log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error) + (typeof incompleteReason === "string" ? ` incompleteReason=${incompleteReason}` : ""));
+				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
 function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
 	const messages = params.messages;
@@ -2004,7 +3145,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();
@@ -2175,4 +3332,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 };