@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/providers/openai-codex/stream.ts

@@ -0,0 +1,367 @@
+import { type ProviderHeaders } from "@earendil-works/pi-ai";
+import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, createAssistantMessageEventStream, getEnvApiKey, type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { hasCodexRequestAuth, resolveCodexRequestAccountId } from "@oai404iao/pi-codex-runtime/internal/codex-http";
+import { resolveCodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { captureCodexTurnState, resolveCodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { applyFastModeServiceTier } from "../../fast-mode.js";
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { rewriteNativeOpenAiTools, type NativeToolRewriteOptions } from "../../provider-native-tools.js";
+import { collectHistoricalCitationSources, collectWebSearchCitationSources } from "@oai404iao/pi-codex-runtime/internal/providers/responses/citations";
+import { webSocketFallbackKey } from "./cache-key.js";
+import { processCapturedResponsesStream } from "./captured-stream.js";
+import type { ProviderStreamEffects } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/stream-effects";
+import { BASE_DELAY_MS, MAX_RETRIES } from "./constants.js";
+import { NonRetryableProviderError, isRetryableError, parseErrorResponse, withHttpStatusPrefix } from "./errors.js";
+import { applyConfiguredResponsesFeatureHeaders, buildSSEHeaders, buildWebSocketHeaders, headersToRecord, providerHeadersToHeaders } from "./headers.js";
+import { withResponsesLiteWebSocketMetadata } from "./lite.js";
+import { createErrorMessage, createInitialAssistantMessage } from "./message.js";
+import { proxyDispatcherForUrl } from "./proxy.js";
+import { buildRequestBody, ensureWebSearchDetailsIncluded } from "./request-body.js";
+import { getLatestUserText } from "./request-context.js";
+import { createCodexRequestId, createPiTurnId, withSseRequestMetadata } from "./request-metadata.js";
+import { isProviderNonTransportError, isRetryableWebSocketError, isWebSocketConnectionLimitReachedError, isWebSocketUpgradeRejectedError, sleep, webSocketRetryDelayMs, webSocketStreamMaxRetries } from "./retry.js";
+import { fetchWithResponseHeaderTimeout, parseSSE, responseHeaderTimeoutMsFromOptions } from "./sse.js";
+import { type ProviderTransport, type ResponsesBody, type WebSocketRequestMetadata } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { resolveCodexUrl, resolveResponsesWebSocketUrl } from "./urls.js";
+import { finalizeUsage, withRequestServiceTier } from "./usage.js";
+import { websocketHttpFallbackSessions } from "./websocket-session.js";
+import { processWebSocketStream } from "./websocket-stream.js";
+
+export function createCodexStream<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	options: SimpleStreamOptions | undefined,
+	deps: ProviderStreamEffects & Pick<NativeToolRewriteOptions, "ownsNativeTool"> & {
+		getCurrentCwd: () => string;
+		getCurrentTurnId?: (sessionId: string | undefined) => string | undefined;
+		getStartupPrewarm?: (sessionId: string, model: Model<Api>) => Promise<void> | undefined;
+	},
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+	const requestCwd = deps.getCurrentCwd();
+
+	(async () => {
+		const output = createInitialAssistantMessage(model);
+		const requestPrompt = getLatestUserText(context);
+		const webSearchCitationSources = collectWebSearchCitationSources(model, context);
+		const historicalCitationSources = collectHistoricalCitationSources(model, context);
+
+		try {
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+			const requestHeaders = options?.headers;
+			const auth = { apiKey: apiKey || undefined, headers: requestHeaders };
+			if (!hasCodexRequestAuth({ modelHeaders: model.headers, auth })) {
+				throw new Error(`No request authentication for provider: ${model.provider}`);
+			}
+
+			const settings = loadModelSettings(model, requestCwd);
+			const requestProfile = resolveCodexRequestProfile(settings.requestProfile);
+			if (
+				!settings.enabled
+				|| !settings.modelProfile?.effective.enabled
+				|| !settings.providerShimActive
+			) {
+				throw new Error(`No enabled Codex model profile for ${model.provider}/${model.id}`);
+			}
+			const apiKeyTransport = settings.apiKeyMode;
+			const accountId = resolveCodexRequestAccountId({
+				modelHeaders: model.headers,
+				auth,
+				apiKeyMode: apiKeyTransport,
+			});
+			const requestIdentity = resolveCodexRequestIdentity(
+				options?.sessionId,
+				options?.metadata as Record<string, unknown> | undefined,
+				"turn",
+			);
+			let body = applyFastModeServiceTier(
+				buildRequestBody(model, context, requestProfile, { ...options, ownsNativeTool: deps.ownsNativeTool }),
+				settings,
+				model,
+			);
+			if (settings.nativeProviderTools) {
+				const webSearch = settings.modelProfile.effective.tools.webSearch;
+				body = rewriteNativeOpenAiTools(body, {
+					ownsNativeTool: deps.ownsNativeTool,
+					imageModel: settings.imageModel,
+					imageGeneration: settings.imageGenerationImplementation ?? false,
+					webSearch: settings.webSearchEnabled && webSearch
+						? {
+								implementation: webSearch.implementation,
+								contentTypes: webSearch.contentTypes,
+							}
+						: false,
+				}).payload;
+			}
+			const nextBody = await options?.onPayload?.(body, model);
+			if (nextBody !== undefined) {
+				body = nextBody as ResponsesBody;
+			}
+			options = withRequestServiceTier(options, body.service_tier);
+			ensureWebSearchDetailsIncluded(body);
+
+			const websocketSessionId = requestIdentity?.sessionId ?? options?.sessionId;
+			const websocketThreadId = requestIdentity?.threadId ?? options?.sessionId;
+			const websocketTurnId = requestIdentity?.turnId
+				|| deps.getCurrentTurnId?.(options?.sessionId)
+				|| createPiTurnId();
+			const websocketRequestId = websocketThreadId
+				|| websocketSessionId
+				|| createCodexRequestId();
+			const websocketRequestMetadata: WebSocketRequestMetadata = {
+				...(options?.sessionId ? { sessionId: options.sessionId } : {}),
+				...(websocketThreadId ? { threadId: websocketThreadId } : {}),
+				turnId: websocketTurnId,
+				...(requestIdentity ? { identity: requestIdentity } : {}),
+			};
+			let sseHeaders = applyConfiguredResponsesFeatureHeaders(
+				buildSSEHeaders(
+					model.headers,
+					requestHeaders,
+					accountId,
+					apiKey,
+					options?.sessionId,
+					requestProfile,
+					websocketThreadId,
+					requestIdentity,
+				),
+				settings,
+				model as Model<Api>,
+			);
+			let websocketHeaders = applyConfiguredResponsesFeatureHeaders(buildWebSocketHeaders(
+				model.headers,
+				requestHeaders,
+				accountId,
+				apiKey,
+				options?.sessionId ?? websocketRequestId,
+				websocketThreadId ?? websocketRequestId,
+				requestIdentity,
+			), settings, model as Model<Api>);
+			const transformHeaders = (
+				options as
+					| (SimpleStreamOptions & {
+							transformHeaders?: (
+								headers: ProviderHeaders,
+							) => ProviderHeaders | Promise<ProviderHeaders>;
+						})
+					| undefined
+			)?.transformHeaders;
+			const bodyJson = JSON.stringify(withSseRequestMetadata(body, websocketRequestMetadata));
+			const responseHeaderTimeoutMs = responseHeaderTimeoutMsFromOptions(options);
+			const configuredTransport: ProviderTransport = settings.openaiTransport;
+			// Pi exposes a session transport setting through stream options. Treat
+			// explicit non-auto values as overrides; otherwise use the model profile.
+			const transport: ProviderTransport = options?.transport && options.transport !== "auto"
+				? options.transport
+				: configuredTransport;
+
+			const websocketUrl = resolveResponsesWebSocketUrl(model.baseUrl, { apiKeyMode: apiKeyTransport });
+			const fallbackKey = webSocketFallbackKey(
+				options?.sessionId,
+				model as Model<Api>,
+				websocketUrl,
+				settings.modelProfileHash,
+			);
+			const sessionFellBackToHttp = transport === "auto"
+				&& fallbackKey !== undefined
+				&& websocketHttpFallbackSessions.has(fallbackKey);
+
+			if (transport !== "sse" && !sessionFellBackToHttp) {
+				if (transformHeaders) {
+					websocketHeaders = providerHeadersToHeaders(
+						await transformHeaders(
+							headersToRecord(websocketHeaders),
+						),
+					);
+				}
+				const startupPrewarmTask = options?.sessionId
+					? deps.getStartupPrewarm?.(options.sessionId, model as Model<Api>)
+					: undefined;
+				const websocketBody = withResponsesLiteWebSocketMetadata(body, requestProfile.responsesMode);
+				let websocketStarted = false;
+				let websocketRetries = 0;
+				const maxWebSocketRetries = webSocketStreamMaxRetries(options);
+				while (true) {
+					websocketStarted = false;
+					try {
+						await processWebSocketStream(
+							websocketUrl,
+							websocketBody,
+							websocketHeaders,
+							output,
+							stream,
+							model,
+							() => {
+								websocketStarted = true;
+							},
+							options,
+							deps,
+							requestCwd,
+							requestPrompt,
+							webSearchCitationSources,
+							historicalCitationSources,
+							websocketRequestMetadata,
+							settings.modelProfileHash,
+							startupPrewarmTask,
+						);
+						if (options?.signal?.aborted) {
+							throw new Error("Request was aborted");
+						}
+						finalizeUsage(model, output);
+						stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse", message: output });
+						stream.end();
+						return;
+					} catch (error) {
+						const aborted = options?.signal?.aborted;
+						const upgradeRejected = isWebSocketUpgradeRejectedError(error);
+						if (
+							transport === "auto"
+							&& !websocketStarted
+							&& upgradeRejected
+						) {
+							if (fallbackKey) websocketHttpFallbackSessions.add(fallbackKey);
+							appendAssistantMessageDiagnostic(
+								output,
+								createAssistantMessageDiagnostic("provider_transport_failure", error, {
+									configuredTransport,
+									fallbackTransport: "sse",
+									eventsEmitted: false,
+									phase: "websocket_upgrade_rejected",
+									retries: websocketRetries,
+									requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+								}),
+							);
+							break;
+						}
+						const retryableTransport = !aborted
+							&& (isWebSocketConnectionLimitReachedError(error) || isRetryableWebSocketError(error));
+						const retryableBeforeStart = !websocketStarted && retryableTransport;
+						if (retryableBeforeStart && websocketRetries < maxWebSocketRetries) {
+							websocketRetries++;
+							await sleep(webSocketRetryDelayMs(error, websocketRetries, options), options?.signal);
+							continue;
+						}
+						if (aborted || (isProviderNonTransportError(error) && !isWebSocketConnectionLimitReachedError(error))) {
+							throw error;
+						}
+						appendAssistantMessageDiagnostic(
+							output,
+							createAssistantMessageDiagnostic("provider_transport_failure", error, {
+								configuredTransport,
+								eventsEmitted: websocketStarted,
+								phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+								retries: websocketRetries,
+								requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+							}),
+						);
+						throw error;
+					}
+				}
+			}
+
+			let response: Response | undefined;
+			let lastError: Error | undefined;
+			const sseUrl = resolveCodexUrl(model.baseUrl, { apiKeyMode: apiKeyTransport });
+			const sseDispatcher = await proxyDispatcherForUrl(sseUrl);
+			if (transformHeaders) {
+				sseHeaders = providerHeadersToHeaders(
+					await transformHeaders(headersToRecord(sseHeaders)),
+				);
+			}
+
+			for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+				if (options?.signal?.aborted) {
+					throw new Error("Request was aborted");
+				}
+
+				try {
+					response = await fetchWithResponseHeaderTimeout(sseUrl, {
+						method: "POST",
+						headers: sseHeaders,
+						body: bodyJson,
+						...(sseDispatcher ? { dispatcher: sseDispatcher } : {}),
+					} as RequestInit, options?.signal, responseHeaderTimeoutMs);
+
+					await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+
+					if (response.ok) {
+						if (options?.sessionId) {
+							captureCodexTurnState(
+								options.sessionId,
+								response.headers.get("x-codex-turn-state") ?? undefined,
+							);
+						}
+						break;
+					}
+
+					const errorText = await response.text();
+					if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+						await sleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+						continue;
+					}
+
+					const fakeResponse = new Response(errorText, {
+						status: response.status,
+						statusText: response.statusText,
+					});
+					const info = await parseErrorResponse(fakeResponse);
+					throw new NonRetryableProviderError(withHttpStatusPrefix(response.status, info.friendlyMessage || info.message));
+				} catch (error) {
+					if (error instanceof NonRetryableProviderError) {
+						throw error;
+					}
+					if (error instanceof Error && (error.name === "AbortError" || error.message === "Request was aborted")) {
+						throw new Error("Request was aborted");
+					}
+
+					lastError = error instanceof Error ? error : new Error(String(error));
+					if (attempt < MAX_RETRIES && !lastError.message.includes("usage limit")) {
+						await sleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+						continue;
+					}
+					throw lastError;
+				}
+			}
+
+			if (!response?.ok) {
+				throw lastError ?? new Error("Failed after retries");
+			}
+
+			if (!response.body) {
+				throw new Error("No response body");
+			}
+
+			stream.push({ type: "start", partial: output });
+			await processCapturedResponsesStream(
+				parseSSE(response),
+				output,
+				stream,
+				model,
+				options,
+				options?.sessionId,
+				deps,
+				requestCwd,
+				requestPrompt,
+				webSearchCitationSources,
+				historicalCitationSources,
+			);
+			finalizeUsage(model, output);
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse", message: output });
+			stream.end();
+		} catch (error) {
+			stream.push({
+				type: "error",
+				reason: (options?.signal?.aborted ? "aborted" : "error") as "aborted" | "error",
+				error: createErrorMessage(output, error, !!options?.signal?.aborted),
+			});
+			stream.end();
+		}
+	})();
+
+	return stream;
+}

package/src/providers/openai-codex/urls.ts

@@ -0,0 +1,24 @@
+import { DEFAULT_CODEX_BASE_URL } from "./constants.js";
+
+export function resolveCodexUrl(baseUrl: string | undefined, options?: { apiKeyMode?: boolean }): string {
+	const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL;
+	const normalized = raw.replace(/\/+$/, "");
+	if (options?.apiKeyMode) {
+		if (normalized.endsWith("/responses")) return normalized;
+		return `${normalized}/responses`;
+	}
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+
+export function resolveResponsesWebSocketUrl(baseUrl: string | undefined, options?: { apiKeyMode?: boolean }): string {
+	const url = new URL(resolveCodexUrl(baseUrl, options));
+	if (url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol === "http:") url.protocol = "ws:";
+	return url.toString();
+}
+
+export function compactUrl(baseUrl: string | undefined, apiKeyMode: boolean): string {
+	return `${resolveCodexUrl(baseUrl, { apiKeyMode }).replace(/\/+$/, "")}/compact`;
+}

package/src/providers/openai-codex/usage.ts

@@ -0,0 +1,60 @@
+import { type Api, type AssistantMessage, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { type ServiceTier } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+function getServiceTierCostMultiplier(
+	model: Model<Api>,
+	serviceTier: ServiceTier,
+	cwd: string,
+): number {
+	if (serviceTier === "flex") return 0.5;
+	const settings = loadModelSettings(model, cwd);
+	return serviceTier && serviceTier === settings.fastServiceTier
+		? settings.fastCostMultiplier ?? 1
+		: 1;
+}
+
+export function applyServiceTierPricing(
+	usage: AssistantMessage["usage"],
+	serviceTier: ServiceTier,
+	model: Model<Api>,
+	cwd: string,
+): void {
+	const multiplier = getServiceTierCostMultiplier(model, serviceTier, cwd);
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+
+export function resolveCodexServiceTier(responseServiceTier: ServiceTier, requestServiceTier: ServiceTier): ServiceTier {
+	if (
+		responseServiceTier === "default"
+		&& (requestServiceTier === "flex" || requestServiceTier === "priority")
+	) {
+		return requestServiceTier;
+	}
+	return responseServiceTier ?? requestServiceTier;
+}
+
+export function withRequestServiceTier(
+	options: SimpleStreamOptions | undefined,
+	serviceTier: unknown,
+): SimpleStreamOptions | undefined {
+	if (
+		serviceTier !== "auto"
+		&& serviceTier !== "default"
+		&& serviceTier !== "flex"
+		&& serviceTier !== "scale"
+		&& serviceTier !== "priority"
+	) {
+		return options;
+	}
+	return { ...options, serviceTier } as SimpleStreamOptions;
+}
+
+export function finalizeUsage<TApi extends Api>(model: Model<TApi>, output: AssistantMessage): void {
+	output.usage.cost.total = output.usage.cost.input + output.usage.cost.output + output.usage.cost.cacheRead + output.usage.cost.cacheWrite;
+}

package/src/providers/openai-codex/websocket-connection.ts

@@ -0,0 +1,216 @@
+import { WEBSOCKET_CONNECT_TIMEOUT_MS } from "./constants.js";
+import { WebSocketHandshakeError, extractWebSocketCloseError, extractWebSocketError } from "./errors.js";
+import { proxyForWebSocketUrl } from "./proxy.js";
+import { dynamicImport } from "./runtime.js";
+import { type NodeWebSocketModule, type WebSocketLike } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+let nodeWebSocketModulePromise: Promise<NodeWebSocketModule> | undefined;
+
+async function loadNodeWebSocketModule(): Promise<NodeWebSocketModule> {
+	if (!nodeWebSocketModulePromise) {
+		nodeWebSocketModulePromise = dynamicImport("ws") as Promise<NodeWebSocketModule>;
+	}
+	return nodeWebSocketModulePromise;
+}
+
+function nodeWebSocketHeaders(headers: Headers): Record<string, string> {
+	return Object.fromEntries(headers.entries());
+}
+
+function nodeWebSocketResponseHeaders(headers: unknown): Record<string, string> {
+	if (!headers || typeof headers !== "object") return {};
+	const result: Record<string, string> = {};
+	for (const [name, value] of Object.entries(headers as Record<string, unknown>)) {
+		if (Array.isArray(value)) result[name] = value.join(", ");
+		else if (typeof value === "string") result[name] = value;
+		else if (value !== undefined) result[name] = String(value);
+	}
+	return result;
+}
+
+function handshakeMessage(status: number, statusText: string | undefined, body: string): string {
+	const trimmedBody = body.trim();
+	if (trimmedBody) {
+		try {
+			const parsed = JSON.parse(trimmedBody) as { error?: { message?: unknown }; message?: unknown };
+			const message = typeof parsed.error?.message === "string"
+				? parsed.error.message
+				: typeof parsed.message === "string"
+					? parsed.message
+					: undefined;
+			if (message?.trim()) return message.trim();
+		} catch {
+			return trimmedBody;
+		}
+	}
+	return statusText?.trim() || "WebSocket upgrade failed";
+}
+
+export async function connectWebSocket(
+	url: string,
+	headers: Headers,
+	signal: AbortSignal | undefined,
+	timeoutMs = WEBSOCKET_CONNECT_TIMEOUT_MS,
+): Promise<WebSocketLike> {
+	if (signal?.aborted) throw new Error("Request was aborted");
+	const { WebSocket } = await loadNodeWebSocketModule();
+	const proxy = proxyForWebSocketUrl(url);
+	let agent: unknown;
+	if (proxy) {
+		const protocol = new URL(proxy).protocol.toLowerCase();
+		if (protocol === "http:" || protocol === "https:") {
+			const { HttpsProxyAgent } = await dynamicImport("https-proxy-agent") as typeof import("https-proxy-agent");
+			agent = new HttpsProxyAgent(proxy);
+		} else if (protocol === "socks:" || protocol === "socks4:" || protocol === "socks4a:" || protocol === "socks5:" || protocol === "socks5h:") {
+			const { SocksProxyAgent } = await dynamicImport("socks-proxy-agent") as {
+				SocksProxyAgent: new (proxy: string) => unknown;
+			};
+			agent = new SocksProxyAgent(proxy);
+		} else {
+			throw new Error(`Unsupported WebSocket proxy protocol: ${protocol}`);
+		}
+	}
+
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let socket: InstanceType<NodeWebSocketModule["WebSocket"]>;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+
+		try {
+			socket = new WebSocket(url, {
+				headers: nodeWebSocketHeaders(headers),
+				perMessageDeflate: true,
+				...(agent ? { agent } : {}),
+			});
+		} catch (error) {
+			reject(error instanceof Error ? error : new Error(String(error)));
+			return;
+		}
+
+		const onOpen = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			// Keep an error listener installed while the socket sits idle in the
+			// session cache. Request parsers add their own listener, but Node's ws
+			// EventEmitter would otherwise treat an idle "error" as uncaught.
+			socket.on("error", () => {});
+			const messageListeners = new Map<(event: unknown) => void, (...args: any[]) => void>();
+			const closeListeners = new Map<(event: unknown) => void, (...args: any[]) => void>();
+			resolve({
+				get readyState() {
+					return socket.readyState;
+				},
+				get bufferedAmount() {
+					return socket.bufferedAmount;
+				},
+				send(data, callback) {
+					socket.send(data, callback);
+				},
+				close(code, reason) {
+					socket.close(code, reason);
+				},
+				addEventListener(type, listener) {
+					if (type === "message") {
+						const wrapped = (data: unknown, isBinary: boolean) => listener({ data, isBinary });
+						messageListeners.set(listener, wrapped);
+						socket.on("message", wrapped);
+						return;
+					}
+					if (type === "close") {
+						const wrapped = (code: number, reason: Buffer) => listener({
+							code,
+							reason: reason.toString("utf8"),
+						});
+						closeListeners.set(listener, wrapped);
+						socket.on("close", wrapped);
+						return;
+					}
+					socket.on(type, listener as (...args: any[]) => void);
+				},
+				removeEventListener(type, listener) {
+					if (type === "message") {
+						const wrapped = messageListeners.get(listener);
+						if (wrapped) socket.off("message", wrapped);
+						messageListeners.delete(listener);
+						return;
+					}
+					if (type === "close") {
+						const wrapped = closeListeners.get(listener);
+						if (wrapped) socket.off("close", wrapped);
+						closeListeners.delete(listener);
+						return;
+					}
+					socket.off(type, listener as (...args: any[]) => void);
+				},
+			});
+		};
+		const onError = (event: unknown) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(event instanceof Error ? event : extractWebSocketError(event));
+		};
+		const onClose = (code: number, reason: Buffer) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(extractWebSocketCloseError({ code, reason: reason.toString("utf8") }));
+		};
+		const onUnexpectedResponse = (
+			_request: unknown,
+			response: { statusCode?: number; statusMessage?: string; headers?: unknown; on(type: string, listener: (...args: any[]) => void): void },
+		) => {
+			if (settled) return;
+			let body = "";
+			response.on("data", (chunk: unknown) => {
+				if (body.length >= 64 * 1024) return;
+				body += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+			});
+			response.on("end", () => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				const status = response.statusCode ?? 500;
+				reject(new WebSocketHandshakeError(
+					status,
+					handshakeMessage(status, response.statusMessage, body),
+					nodeWebSocketResponseHeaders(response.headers),
+					body || undefined,
+				));
+			});
+		};
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			socket.on("error", () => {});
+			socket.terminate?.();
+			reject(new Error("Request was aborted"));
+		};
+		const onTimeout = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			socket.on("error", () => {});
+			socket.terminate?.();
+			reject(new Error(`OpenAI Responses WebSocket connection timed out after ${timeoutMs}ms`));
+		};
+
+		const cleanup = () => {
+			if (timeout) clearTimeout(timeout);
+			socket.off("open", onOpen);
+			socket.off("error", onError);
+			socket.off("close", onClose);
+			socket.off("unexpected-response", onUnexpectedResponse);
+			signal?.removeEventListener("abort", onAbort);
+		};
+
+		socket.on("open", onOpen);
+		socket.on("error", onError);
+		socket.on("close", onClose);
+		socket.on("unexpected-response", onUnexpectedResponse);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		timeout = setTimeout(onTimeout, Math.max(1, timeoutMs));
+	});
+}