@openclaw/ai 2026.9.7 → 2026.10.1-beta.1

package/dist/{openai-chatgpt-responses-CYbidtrn.mjs → openai-chatgpt-responses-BC2x0Oqx.mjs}

@@ -1,25 +1,26 @@
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-vd9UnCAU.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-C5AbCAaZ.mjs";
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { S as headersToRecord, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-CHi3X87F.mjs";
-import { d as supportsOpenAITemperature } from "./openai-reasoning-effort-ConhwkeX.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-D2V7MqR7.mjs";
-import { _ as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as toErrorObject } from "./diagnostics-CJaB6g8J.mjs";
-import { s as resolveTimerTimeoutMs } from "./base64-C1PsYcRQ.mjs";
-import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-C-4bf2Ok.mjs";
+import { r as clampPositiveTimerTimeoutMs } from "./number-coercion-V8-BhME4.mjs";
+import { E as headersToRecord, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-DCW52iHe.mjs";
+import { D as supportsOpenAITemperature, h as responsesPromptObserver } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-I8YQTzf8.mjs";
+import { _ as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as toErrorObject } from "./diagnostics-Caj-4RBA.mjs";
+import { n as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./text-signature-MLwfi6fq.mjs";
 import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-Dh5qKJ8e.mjs";
-import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-CGAkCwtM.mjs";
-import { b as createOpenAIResponseHook, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, x as createResponseModelTracker, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-BwlpzX-2.mjs";
-import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
-import { n as createAssistantOutput } from "./provider-transcript-transform-JbFbHV8h.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-B9o0S4SZ.mjs";
-import { h as responsesPromptObserver } from "./openai-responses-contracts-CLxnqS9p.mjs";
-import { A as recordResponsesContextUsage, P as convertProviderResponsesMessages, S as isInvalidEncryptedContentError, T as ResponsesStreamFailure, Z as suppressOpenAIResponsesCompaction, b as commitResponsesEncryptedContentAttempt, i as convertResponsesToolPayload, n as applyResponsesServiceTierPricing, o as readOpenAIMisalignmentReview, q as buildOpenAIResponsesReasoningReplayMetadata, s as processResponsesStream, w as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DL4ulQn7.mjs";
+import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-BdmlhD4u.mjs";
+import { n as buildManagedModelFetch } from "./host-policy-B3jc4Rpn.mjs";
+import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CxXXz_Dd.mjs";
+import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BkKTXxhp.mjs";
+import { b as createOpenAIResponseHook, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, x as createResponseModelTracker, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-JFsnIyto.mjs";
+import { t as createAssistantOutput } from "./assistant-output-OLm-Oln0.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.mjs";
+import { A as recordResponsesContextUsage, J as buildOpenAIResponsesReasoningReplayMetadata, P as convertProviderResponsesMessages, S as isInvalidEncryptedContentError, T as ResponsesStreamFailure, Z as suppressOpenAIResponsesCompaction, b as commitResponsesEncryptedContentAttempt, i as convertResponsesToolPayload, n as applyResponsesServiceTierPricing, o as readOpenAIMisalignmentReview, s as processResponsesStream, w as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-C7oVyjED.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
-import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
-import { i as resolveOpenAIResponsesTextFormat, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-iAqLb4tk.mjs";
+import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-CCg7B6l4.mjs";
 import { n as withResponsesRequestAcceptance, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-Fsag-IGZ.mjs";
+import { t as requireApiKey } from "./required-api-key-D4kn3252.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
 //#region packages/ai/src/providers/openai-chatgpt-responses-events.ts
 var CodexApiError = class extends Error {
@@ -138,6 +139,142 @@ async function* parseOpenAIChatGptResponsesSse(response) {
 		} catch {}
 	}
 }
+const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+function resolveCodexUrl(baseUrl) {
+	const normalized = (baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+function resolveCodexWebSocketUrl(baseUrl) {
+	const url = new URL(resolveCodexUrl(baseUrl));
+	if (url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol === "http:") url.protocol = "ws:";
+	return url.toString();
+}
+//#endregion
+//#region packages/ai/src/providers/openai-chatgpt-responses-websocket-authority.ts
+const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+function createCodexWebSocketAuthority(transportHost, baseUrl, headers) {
+	return {
+		transportHost,
+		url: resolveCodexWebSocketUrl(baseUrl),
+		headers,
+		normalizedHeaders: Array.from(headers.entries()).filter(([name]) => name !== "traceparent")
+	};
+}
+function resolveCodexWebSocketAuthority(params) {
+	return params.transport === "sse" ? void 0 : createCodexWebSocketAuthority(params.transportHost, params.baseUrl, params.headers());
+}
+function buildCodexWebSocketHeaders(baseHeaders, requestId) {
+	baseHeaders.delete("accept");
+	baseHeaders.delete("content-type");
+	baseHeaders.delete("OpenAI-Beta");
+	baseHeaders.delete("openai-beta");
+	baseHeaders.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+	baseHeaders.set("x-client-request-id", requestId);
+	baseHeaders.set("session_id", requestId);
+	return baseHeaders;
+}
+function matchesCodexWebSocketAuthority(cached, requested) {
+	return cached.transportHost === requested.transportHost && cached.url === requested.url && cached.normalizedHeaders.length === requested.normalizedHeaders.length && cached.normalizedHeaders.every(([name, value], index) => name === requested.normalizedHeaders[index]?.[0] && value === requested.normalizedHeaders[index]?.[1]);
+}
+const MAX_SSE_FALLBACK_AUTHORITIES_PER_SESSION = 8;
+function hasCodexWebSocketSseFallback(fallbacksBySession, sessionId, authority) {
+	return Boolean(sessionId && fallbacksBySession.get(sessionId)?.some((fallback) => matchesCodexWebSocketAuthority(fallback, authority)));
+}
+function addCodexWebSocketSseFallback(fallbacksBySession, sessionId, authority) {
+	const fallbacks = fallbacksBySession.get(sessionId) ?? [];
+	if (fallbacks.some((fallback) => matchesCodexWebSocketAuthority(fallback, authority))) return;
+	if (fallbacks.length === MAX_SSE_FALLBACK_AUTHORITIES_PER_SESSION) fallbacks.shift();
+	fallbacks.push(authority);
+	if (!fallbacksBySession.has(sessionId)) fallbacksBySession.set(sessionId, fallbacks);
+}
+function clearCodexWebSocketSseFallback(fallbacksBySession, sessionId) {
+	if (sessionId) {
+		fallbacksBySession.delete(sessionId);
+		return;
+	}
+	fallbacksBySession.clear();
+}
+//#endregion
+//#region packages/ai/src/providers/openai-chatgpt-responses-websocket-state.ts
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
+const runtimeStates = /* @__PURE__ */ new WeakMap();
+const runtimeStateReferences = /* @__PURE__ */ new Set();
+const runtimeStateFinalizer = new FinalizationRegistry((reference) => runtimeStateReferences.delete(reference));
+function getOpenAICodexWebSocketRuntimeState(transportHost) {
+	let state = runtimeStates.get(transportHost);
+	if (!state) {
+		state = {
+			sessionCache: /* @__PURE__ */ new Map(),
+			sseFallbacks: /* @__PURE__ */ new Map()
+		};
+		runtimeStates.set(transportHost, state);
+		const reference = new WeakRef(state);
+		runtimeStateReferences.add(reference);
+		runtimeStateFinalizer.register(state, reference, reference);
+	}
+	return state;
+}
+function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
+	try {
+		socket.close(code, reason);
+	} catch {}
+}
+function isWebSocketReusable(socket) {
+	return socket.readyState === void 0 || socket.readyState === 1;
+}
+function isWebSocketSessionExpired(entry) {
+	return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+}
+function deleteOwnedWebSocketSession(state, sessionId, entry) {
+	if (state.sessionCache.get(sessionId) === entry) state.sessionCache.delete(sessionId);
+}
+function setOwnedWebSocketSession(state, sessionId, entry, expected) {
+	if (state.sessionCache.get(sessionId) !== expected) return false;
+	state.sessionCache.set(sessionId, entry);
+	return true;
+}
+function scheduleSessionWebSocketExpiry(state, sessionId, entry) {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy) return;
+		closeWebSocketSilently(entry.socket, 1e3, "idle_timeout");
+		deleteOwnedWebSocketSession(state, sessionId, entry);
+	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
+}
+function closeRuntimeState(state, sessionId) {
+	const closeEntry = (entry) => {
+		if (entry.idleTimer) clearTimeout(entry.idleTimer);
+		closeWebSocketSilently(entry.socket, 1e3, "debug_close");
+	};
+	if (sessionId) {
+		clearCodexWebSocketSseFallback(state.sseFallbacks, sessionId);
+		const entry = state.sessionCache.get(sessionId);
+		if (entry) closeEntry(entry);
+		state.sessionCache.delete(sessionId);
+		return;
+	}
+	for (const entry of state.sessionCache.values()) closeEntry(entry);
+	state.sessionCache.clear();
+	clearCodexWebSocketSseFallback(state.sseFallbacks);
+}
+function closeOpenAICodexWebSocketState(transportHost, sessionId) {
+	const state = runtimeStates.get(transportHost);
+	if (state) closeRuntimeState(state, sessionId);
+}
+function closeAllOpenAICodexWebSocketStates(sessionId) {
+	for (const reference of runtimeStateReferences) {
+		const state = reference.deref();
+		if (!state) {
+			runtimeStateReferences.delete(reference);
+			continue;
+		}
+		closeRuntimeState(state, sessionId);
+	}
+}
 //#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses.ts
 const dynamicImport = (specifier) => import(specifier);
@@ -146,7 +283,6 @@ function loadNodeOs() {
 	return process.getBuiltinModule?.("node:os") ?? null;
 }
 const os = loadNodeOs();
-const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "opencode"]);
 const WEBSOCKET_TRANSPORT_ERROR_CODE = "ERR_WEBSOCKET_TRANSPORT";
@@ -163,10 +299,6 @@ const RETRYABLE_WEBSOCKET_CLOSE_CODES = /* @__PURE__ */ new Set([
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
 const OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES = 16384;
-function resolveRequestTimeoutMs(options) {
-	const timeoutMs = options?.timeoutMs;
-	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? resolveTimerTimeoutMs(timeoutMs, 1) : void 0;
-}
 function buildRequestSignal(baseSignal, timeoutMs) {
 	if (timeoutMs === void 0) return baseSignal;
 	const timeoutSignal = AbortSignal.timeout(timeoutMs);
@@ -208,9 +340,10 @@ const streamOpenAICodexResponses = (model, context, options) => {
 		let firstEventAbort;
 		const output = createAssistantOutput(model);
 		try {
-			const unresolvedApiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			if (!unresolvedApiKey) throw new Error(`No API key for provider: ${model.provider}`);
-			const apiKey = getAiTransportHost().resolveSecretSentinel(unresolvedApiKey);
+			const unresolvedApiKey = requireApiKey(model.provider, options?.apiKey);
+			const transportHost = getAiTransportHost();
+			const websocketState = getOpenAICodexWebSocketRuntimeState(transportHost);
+			const apiKey = transportHost.resolveSecretSentinel(unresolvedApiKey);
 			const modelHeaders = resolveAiTransportHeaderSentinels(model.headers);
 			const optionHeaders = resolveAiTransportHeaderSentinels(options?.headers);
 			const accountId = extractOpenAICodexAccountId(apiKey);
@@ -227,7 +360,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const commitSemanticAttempt = (attempt) => commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint));
 			const observePromptEgress = createResponsesPromptEgressObserver(options, context.systemPrompt);
 			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
-			requestTimeoutMs = resolveRequestTimeoutMs(options);
+			requestTimeoutMs = clampPositiveTimerTimeoutMs(options?.timeoutMs);
 			requestTimeoutSignal = buildRequestSignal(options?.signal, requestTimeoutMs);
 			firstEventAbort = createFirstStreamEventAbortController(requestTimeoutSignal);
 			activeSignal = firstEventAbort.signal;
@@ -236,9 +369,25 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				signal: activeSignal
 			};
 			const transport = options?.transport || "auto";
-			const websocketDisabledForSession = transport === "auto" && isWebSocketSseFallbackActive(options?.sessionId);
-			if (transport !== "sse" && !websocketDisabledForSession) {
-				const websocketHeaders = buildWebSocketHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId || createCodexRequestId());
+			let websocketAuthority;
+			if (!transportHost.requiresManagedTransport(model)) try {
+				websocketAuthority = resolveCodexWebSocketAuthority({
+					transport,
+					transportHost,
+					baseUrl: model.baseUrl,
+					headers: () => buildCodexWebSocketHeaders(buildBaseCodexHeaders(modelHeaders, optionHeaders, accountId, apiKey), sessionId || createCodexRequestId())
+				});
+			} catch (error) {
+				if (transport !== "auto") throw error;
+				appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
+					configuredTransport: transport,
+					fallbackTransport: "sse",
+					eventsEmitted: false,
+					phase: "before_message_stream_start"
+				}));
+			}
+			const websocketDisabledForSession = transport === "auto" && websocketAuthority !== void 0 && hasCodexWebSocketSseFallback(websocketState.sseFallbacks, options?.sessionId, websocketAuthority);
+			if (websocketAuthority && !websocketDisabledForSession) {
 				let websocketStarted = false;
 				let websocketRequestSent = false;
 				let retriedWebSocketConnectionLimit = false;
@@ -247,7 +396,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					websocketStarted = false;
 					websocketRequestSent = false;
 					try {
-						const terminal = await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), activeAttempt.request, websocketHeaders, output, stream, model, () => {
+						const terminal = await processWebSocketStream(websocketState, websocketAuthority, activeAttempt.request, output, stream, model, () => {
 							websocketStarted = true;
 						}, () => {
 							commitSemanticAttempt(activeAttempt);
@@ -285,7 +434,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
 							requestBytes: new TextEncoder().encode(JSON.stringify(activeAttempt.request)).byteLength
 						}));
-						if (transport === "auto" && options?.sessionId) websocketSseFallbackSessions.add(options.sessionId);
+						if (transport === "auto" && options?.sessionId) addCodexWebSocketSseFallback(websocketState.sseFallbacks, options.sessionId, websocketAuthority);
 						if (websocketStarted || transport !== "auto") throw error;
 						break;
 					}
@@ -313,7 +462,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 						activeSignal?.throwIfAborted();
 						lifecycle.assertCurrent();
 					}
-					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
+					attemptResponse = await (buildManagedModelFetch(model, transportHost) ?? fetch)(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
 						body: sseBody,
@@ -424,8 +573,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 	return stream;
 };
 const streamSimpleOpenAICodexResponses = (model, context, options) => {
-	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const apiKey = requireApiKey(model.provider, options?.apiKey);
 	const resolvedOptions = {
 		...buildBaseOptions(model, options, apiKey),
 		authProfileId: options?.authProfileId,
@@ -479,18 +627,6 @@ function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 	if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) return requestServiceTier;
 	return responseServiceTier ?? requestServiceTier;
 }
-function resolveCodexUrl(baseUrl) {
-	const normalized = (baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
-	if (normalized.endsWith("/codex/responses")) return normalized;
-	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
-	return `${normalized}/codex/responses`;
-}
-function resolveCodexWebSocketUrl(baseUrl) {
-	const url = new URL(resolveCodexUrl(baseUrl));
-	if (url.protocol === "https:") url.protocol = "wss:";
-	if (url.protocol === "http:") url.protocol = "ws:";
-	return url.toString();
-}
 /**
 * Structured refusal code carried by the OpenAI Responses transport. Every
 * terminal Responses path preserves it: a non-OK HTTP body parsed by
@@ -521,36 +657,18 @@ function isCodexNonTransportError(error) {
 function isWebSocketConnectionLimitReachedError(error) {
 	return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
 }
-const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
-const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
-const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
-const websocketSessionCache = /* @__PURE__ */ new Map();
-const websocketSseFallbackSessions = /* @__PURE__ */ new Set();
 let cachedWebsocket = null;
 function resetOpenAICodexWebSocketStateForTest() {
 	cachedWebsocket = null;
-	websocketSseFallbackSessions.clear();
 }
-function closeOpenAICodexWebSocketSessions(sessionId) {
-	const closeEntry = (entry) => {
-		if (entry.idleTimer) clearTimeout(entry.idleTimer);
-		closeWebSocketSilently(entry.socket, 1e3, "debug_close");
-	};
-	if (sessionId) {
-		websocketSseFallbackSessions.delete(sessionId);
-		const entry = websocketSessionCache.get(sessionId);
-		if (entry) closeEntry(entry);
-		websocketSessionCache.delete(sessionId);
+function closeOpenAICodexWebSocketSessions(sessionId, owner) {
+	if (owner) {
+		closeOpenAICodexWebSocketState(owner, sessionId);
 		return;
 	}
-	for (const entry of websocketSessionCache.values()) closeEntry(entry);
-	websocketSessionCache.clear();
-	websocketSseFallbackSessions.clear();
+	closeAllOpenAICodexWebSocketStates(sessionId);
 }
 registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
-function isWebSocketSseFallbackActive(sessionId) {
-	return sessionId ? websocketSseFallbackSessions.has(sessionId) : false;
-}
 async function getWebSocketConstructor() {
 	if (cachedWebsocket) return cachedWebsocket;
 	if (process?.versions?.bun && (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)) {
@@ -576,40 +694,6 @@ async function getWebSocketConstructor() {
 function createWebSocketTransportError(message, cause) {
 	return Object.assign(new Error(message, cause ? { cause } : void 0), { code: extractErrorCodeOrErrno(cause) ?? WEBSOCKET_TRANSPORT_ERROR_CODE });
 }
-function getWebSocketReadyState(socket) {
-	const readyState = socket.readyState;
-	return typeof readyState === "number" ? readyState : void 0;
-}
-function isWebSocketReusable(socket) {
-	const readyState = getWebSocketReadyState(socket);
-	return readyState === void 0 || readyState === 1;
-}
-function isWebSocketSessionExpired(entry) {
-	return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
-}
-function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
-	try {
-		socket.close(code, reason);
-	} catch {}
-}
-function deleteOwnedWebSocketSession(sessionId, entry) {
-	if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
-}
-function setOwnedWebSocketSession(sessionId, entry, expected) {
-	if (websocketSessionCache.get(sessionId) === expected) {
-		websocketSessionCache.set(sessionId, entry);
-		return true;
-	}
-	return false;
-}
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
-	if (entry.idleTimer) clearTimeout(entry.idleTimer);
-	entry.idleTimer = setTimeout(() => {
-		if (entry.busy) return;
-		closeWebSocketSilently(entry.socket, 1e3, "idle_timeout");
-		deleteOwnedWebSocketSession(sessionId, entry);
-	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
-}
 async function connectWebSocket(url, headers, signal) {
 	const WebSocketCtor = await getWebSocketConstructor();
 	if (!WebSocketCtor) throw new Error("WebSocket transport is not available in this runtime");
@@ -667,79 +751,57 @@ async function connectWebSocket(url, headers, signal) {
 		signal?.addEventListener("abort", onAbort);
 	});
 }
-async function acquireWebSocket(url, headers, sessionId, signal) {
-	if (!sessionId) {
-		const socket = await connectWebSocket(url, headers, signal);
-		return {
-			socket,
-			release: () => {
+async function acquireWebSocket(state, authority, sessionId, signal) {
+	const { url, headers } = authority;
+	const lease = (socket, entry) => ({
+		socket,
+		entry,
+		release: ({ keep } = {}) => {
+			if (!sessionId || !entry || !keep || !isWebSocketReusable(socket)) {
 				closeWebSocketSilently(socket);
+				if (entry?.idleTimer) clearTimeout(entry.idleTimer);
+				if (sessionId && entry) deleteOwnedWebSocketSession(state, sessionId, entry);
+				return;
 			}
-		};
-	}
-	const cached = websocketSessionCache.get(sessionId);
+			entry.busy = false;
+			scheduleSessionWebSocketExpiry(state, sessionId, entry);
+		}
+	});
+	if (!sessionId) return lease(await connectWebSocket(url, headers, signal));
+	const cached = state.sessionCache.get(sessionId);
 	let expectedCacheValue = cached;
 	if (cached) {
 		if (cached.idleTimer) {
 			clearTimeout(cached.idleTimer);
 			cached.idleTimer = void 0;
 		}
-		if (!cached.busy && isWebSocketSessionExpired(cached)) {
+		if (!cached.busy && !matchesCodexWebSocketAuthority(cached.authority, authority)) {
+			closeWebSocketSilently(cached.socket, 1e3, "authority_changed");
+			deleteOwnedWebSocketSession(state, sessionId, cached);
+			expectedCacheValue = void 0;
+		} else if (!cached.busy && isWebSocketSessionExpired(cached)) {
 			closeWebSocketSilently(cached.socket, 1e3, "connection_age_limit");
-			deleteOwnedWebSocketSession(sessionId, cached);
+			deleteOwnedWebSocketSession(state, sessionId, cached);
 			expectedCacheValue = void 0;
 		} else if (!cached.busy && isWebSocketReusable(cached.socket)) {
 			cached.busy = true;
-			return {
-				socket: cached.socket,
-				entry: cached,
-				release: ({ keep } = {}) => {
-					if (!keep || !isWebSocketReusable(cached.socket)) {
-						closeWebSocketSilently(cached.socket);
-						deleteOwnedWebSocketSession(sessionId, cached);
-						return;
-					}
-					cached.busy = false;
-					scheduleSessionWebSocketExpiry(sessionId, cached);
-				}
-			};
-		}
-		if (cached.busy) {
-			const socket = await connectWebSocket(url, headers, signal);
-			return {
-				socket,
-				release: () => {
-					closeWebSocketSilently(socket);
-				}
-			};
+			return lease(cached.socket, cached);
 		}
+		if (cached.busy) return lease(await connectWebSocket(url, headers, signal));
 		if (!isWebSocketReusable(cached.socket)) {
 			closeWebSocketSilently(cached.socket);
-			deleteOwnedWebSocketSession(sessionId, cached);
+			deleteOwnedWebSocketSession(state, sessionId, cached);
 			expectedCacheValue = void 0;
 		}
 	}
 	const socket = await connectWebSocket(url, headers, signal);
 	const entry = {
 		socket,
+		authority,
 		busy: true,
 		createdAt: Date.now()
 	};
-	const ownsCache = setOwnedWebSocketSession(sessionId, entry, expectedCacheValue);
-	return {
-		socket,
-		entry: ownsCache ? entry : void 0,
-		release: ({ keep } = {}) => {
-			if (!ownsCache || !keep || !isWebSocketReusable(entry.socket)) {
-				closeWebSocketSilently(entry.socket);
-				if (entry.idleTimer) clearTimeout(entry.idleTimer);
-				deleteOwnedWebSocketSession(sessionId, entry);
-				return;
-			}
-			entry.busy = false;
-			scheduleSessionWebSocketExpiry(sessionId, entry);
-		}
-	};
+	return lease(socket, setOwnedWebSocketSession(state, sessionId, entry, expectedCacheValue) ? entry : void 0);
 }
 function extractWebSocketError(event) {
 	if (event && typeof event === "object") {
@@ -903,8 +965,8 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onFirst
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
-	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+async function processWebSocketStream(state, authority, body, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
+	const { socket, entry, release } = await acquireWebSocket(state, authority, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
 	const fullBody = body;
@@ -1080,16 +1142,5 @@ function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessi
 	}
 	return headers;
 }
-function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, requestId) {
-	const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
-	headers.delete("accept");
-	headers.delete("content-type");
-	headers.delete("OpenAI-Beta");
-	headers.delete("openai-beta");
-	headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
-	headers.set("x-client-request-id", requestId);
-	headers.set("session_id", requestId);
-	return headers;
-}
 //#endregion
 export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };

package/dist/openai-completions-DNyHnXKg.mjs

@@ -0,0 +1,25 @@
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
+import { k as clampThinkingLevel } from "./host-DCW52iHe.mjs";
+import { n as buildBaseOptions } from "./simple-options-BkKTXxhp.mjs";
+import { i as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-DWM2mQDB.mjs";
+import { t as requireApiKey } from "./required-api-key-D4kn3252.mjs";
+//#region packages/ai/src/providers/openai-completions.ts
+var openai_completions_exports = /* @__PURE__ */ __exportAll({
+	convertMessages: () => convertMessages,
+	streamOpenAICompletions: () => streamOpenAICompletions,
+	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
+});
+const streamOpenAICompletions = (model, context, options) => streamOpenAICompletionsRequest(model, context, options, "direct");
+const streamSimpleOpenAICompletions = (model, context, options) => {
+	const apiKey = requireApiKey(model.provider, options?.apiKey);
+	const base = buildBaseOptions(model, options, apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+	const toolChoice = options?.toolChoice;
+	return streamOpenAICompletions(model, context, {
+		...base,
+		reasoningEffort: clampedReasoning,
+		toolChoice
+	});
+};
+//#endregion
+export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };

package/dist/{openai-completions-compat-qJjmqQ71.d.mts → openai-completions-compat-BYdYpXhU.d.mts}

@@ -1,6 +1,6 @@
-import "./index-D6KsSE74.mjs";
-import { M as OpenAICompletionsCompat, O as Model } from "./types-CLLR3eB4.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-rxlNaBwm.mjs";
+import "./index-a8e_oKnu.mjs";
+import { N as OpenAICompletionsCompat, k as Model } from "./types-DvzmWW8J.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-BinBeGcQ.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";

package/dist/{openai-completions-compat-BOVWBZDn.mjs → openai-completions-compat-BdmlhD4u.mjs}

@@ -1,5 +1,5 @@
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { i as resolveProviderRequestCapabilities } from "./host-policy-BOAwRg_M.mjs";
+import { a as resolveProviderRequestCapabilities } from "./host-policy-B3jc4Rpn.mjs";
 //#region packages/ai/src/providers/openai-response-format.ts
 const JSON_SCHEMA_RESPONSE_FORMAT_NAME = "openclaw_response";
 const OLLAMA_CLOUD_ORIGIN = "https://ollama.com";
@@ -16,11 +16,7 @@ function isKnownOpenAIJsonSchemaModelId(modelId) {
 function shouldOmitOllamaCompatResponseFormat(params) {
 	if (!params.provider.includes("ollama")) return false;
 	if (params.hasTools()) return true;
-	try {
-		return new URL(params.baseUrl).origin === OLLAMA_CLOUD_ORIGIN;
-	} catch {
-		return false;
-	}
+	return URL.parse(params.baseUrl)?.origin === OLLAMA_CLOUD_ORIGIN;
 }
 /**
 * Maps the shared JSON Schema option to Chat Completions while preserving the
@@ -38,6 +34,22 @@ function resolveOpenAICompletionsResponseFormat(responseFormat, supportsJsonSche
 		}
 	};
 }
+/** Maps shared or provider-shaped structured-output options to the Responses API text format. */
+function resolveOpenAIResponsesTextFormat(responseFormat) {
+	if (responseFormat.type === "json_schema") return {
+		...isRecord(responseFormat.json_schema) ? responseFormat.json_schema : responseFormat,
+		type: "json_schema"
+	};
+	if (responseFormat.type === "json_object" || responseFormat.type === "text") return {
+		...responseFormat,
+		type: responseFormat.type
+	};
+	return {
+		type: "json_schema",
+		name: JSON_SCHEMA_RESPONSE_FORMAT_NAME,
+		schema: responseFormat
+	};
+}
 //#endregion
 //#region packages/ai/src/transports/openai-completions-compat.ts
 function isDefaultRouteProvider(provider, ...ids) {
@@ -55,22 +67,17 @@ function isOpenAICodexResponsesModel(model) {
 }
 function isNativeOpenAICodexResponsesBaseUrl(baseUrl) {
 	const trimmed = typeof baseUrl === "string" ? baseUrl.trim() : "";
-	if (!trimmed) return false;
-	try {
-		const url = new URL(trimmed);
-		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-		if (url.hostname.toLowerCase() !== "chatgpt.com") return false;
-		const pathname = url.pathname.replace(/\/+$/u, "").toLowerCase();
-		return [
-			"/backend-api",
-			"/backend-api/v1",
-			"/backend-api/codex",
-			"/backend-api/codex/v1",
-			"/backend-api/codex/responses"
-		].includes(pathname);
-	} catch {
-		return false;
-	}
+	const url = URL.parse(trimmed);
+	if (!url || url.protocol !== "http:" && url.protocol !== "https:") return false;
+	if (url.hostname.toLowerCase() !== "chatgpt.com") return false;
+	const pathname = url.pathname.replace(/\/+$/u, "").toLowerCase();
+	return [
+		"/backend-api",
+		"/backend-api/v1",
+		"/backend-api/codex",
+		"/backend-api/codex/v1",
+		"/backend-api/codex/responses"
+	].includes(pathname);
 }
 function usesNativeOpenAICodexResponsesBackend(model) {
 	return isOpenAICodexResponsesModel(model) && isNativeOpenAICodexResponsesBaseUrl(model.baseUrl);
@@ -170,4 +177,4 @@ function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
 	};
 }
 //#endregion
-export { resolveOpenAIPromptCacheKeySupport as a, shouldOmitOllamaCompatResponseFormat as c, resolveOpenAICompletionsCompat as i, isNativeOpenAIEndpoint as n, usesNativeOpenAICodexResponsesBackend as o, isOpenAICodexResponsesModel as r, resolveOpenAICompletionsResponseFormat as s, detectOpenAICompletionsCompat as t };
+export { resolveOpenAIPromptCacheKeySupport as a, resolveOpenAIResponsesTextFormat as c, resolveOpenAICompletionsCompat as i, shouldOmitOllamaCompatResponseFormat as l, isNativeOpenAIEndpoint as n, usesNativeOpenAICodexResponsesBackend as o, isOpenAICodexResponsesModel as r, resolveOpenAICompletionsResponseFormat as s, detectOpenAICompletionsCompat as t };