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

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

@@ -0,0 +1,130 @@
+import { type StreamEventShape } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export class NonRetryableProviderError extends Error {}
+
+export class ProviderResponseError extends Error {
+	code?: string;
+	errorType?: string;
+	status?: number;
+	retryAfterMs?: number;
+}
+
+export class ProviderProtocolError extends Error {}
+
+export class WebSocketHandshakeError extends Error {
+	constructor(
+		public readonly status: number,
+		message: string,
+		public readonly headers: Record<string, string> = {},
+		public readonly body?: string,
+	) {
+		super(withHttpStatusPrefix(status, message));
+		this.name = "WebSocketHandshakeError";
+	}
+}
+
+const HTTP_STATUS_MESSAGE_PREFIX = /^HTTP\s+\d{3}(?::|\b)/i;
+
+export function isRetryableError(status: number, errorText: string): boolean {
+	if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) {
+		return true;
+	}
+	return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
+}
+
+export function withHttpStatusPrefix(status: number, message: string): string {
+	const trimmed = message.trim() || "Request failed";
+	if (HTTP_STATUS_MESSAGE_PREFIX.test(trimmed)) return trimmed;
+	return `HTTP ${status}: ${trimmed}`;
+}
+
+export function extractWebSocketError(event: unknown): Error {
+	if (event && typeof event === "object") {
+		const message = "message" in event ? (event as { message?: unknown }).message : undefined;
+		if (typeof message === "string" && message.length > 0) {
+			return new Error(message);
+		}
+		const nestedError = "error" in event ? (event as { error?: unknown }).error : undefined;
+		if (nestedError instanceof Error && nestedError.message.length > 0) {
+			return nestedError;
+		}
+		if (nestedError && typeof nestedError === "object" && "message" in nestedError) {
+			const nestedMessage = (nestedError as { message?: unknown }).message;
+			if (typeof nestedMessage === "string" && nestedMessage.length > 0) {
+				return new Error(nestedMessage);
+			}
+		}
+	}
+	return new Error("WebSocket error");
+}
+
+export function extractWebSocketCloseError(event: unknown): Error {
+	if (event && typeof event === "object") {
+		const code = "code" in event ? (event as { code?: unknown }).code : undefined;
+		const reason = "reason" in event ? (event as { reason?: unknown }).reason : undefined;
+		const codeText = typeof code === "number" ? ` ${code}` : "";
+		const reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
+		return new Error(`WebSocket closed${codeText}${reasonText}`.trim());
+	}
+	return new Error("WebSocket closed");
+}
+
+export function friendlyUsageLimitMessage(error: StreamEventShape["error"], status: number | undefined): string | undefined {
+	const code = error?.code ?? error?.type ?? "";
+	if (!/usage_limit_reached|usage_not_included/i.test(code)) {
+		return undefined;
+	}
+	const plan = error?.plan_type ? ` (${error.plan_type.toLowerCase()} plan)` : "";
+	const mins = error?.resets_at
+		? Math.max(0, Math.round((error.resets_at * 1000 - Date.now()) / 60_000))
+		: undefined;
+	const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+	return `You have hit your OpenAI usage limit${plan}.${when}`.trim();
+}
+
+export function buildProviderErrorMessage(error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error);
+	const candidate = error as { code?: unknown; errorType?: unknown; status?: unknown };
+	if (
+		candidate?.code === "stream_read_error"
+		&& candidate.errorType === "upstream_error"
+	) {
+		// Pi's agent-level retry classifier recognizes "connection error". Surface
+		// this upstream SSE read failure in that category instead of
+		// retrying inside the provider, so Pi's retry settings and UI remain the
+		// single source of truth.
+		return `Connection error: ${message}`;
+	}
+	if (/^(?:WebSocket (?:error|closed)|WebSocket stream closed before response\.completed|Stream closed before response\.completed)/.test(message)) {
+		return `Connection error: ${message}`;
+	}
+	if (typeof candidate?.status === "number") {
+		return withHttpStatusPrefix(candidate.status, message);
+	}
+	return message;
+}
+
+export async function parseErrorResponse(response: Response): Promise<{ message: string; friendlyMessage?: string }> {
+	const raw = await response.text();
+	let message = raw || response.statusText || "Request failed";
+	let friendlyMessage: string | undefined;
+
+	try {
+		const parsed = JSON.parse(raw) as { error?: { code?: string; type?: string; plan_type?: string; resets_at?: number; message?: string } };
+		const err = parsed?.error;
+		if (err) {
+			const code = err.code || err.type || "";
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+				const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
+				const mins = err.resets_at ? Math.max(0, Math.round((err.resets_at * 1000 - Date.now()) / 60000)) : undefined;
+				const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+				friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
+			}
+			message = err.message || friendlyMessage || message;
+		}
+	} catch {
+		// ignore malformed error bodies
+	}
+
+	return { message, friendlyMessage };
+}

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

@@ -0,0 +1,123 @@
+import { captureCodexTurnState } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { CODEX_RESPONSE_STATUSES } from "./constants.js";
+import { ProviderResponseError, friendlyUsageLimitMessage } from "./errors.js";
+import { retryAfterMsFromHeaders } from "./retry.js";
+import { type StreamEventShape } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export async function* mapCodexEvents(
+	events: AsyncIterable<StreamEventShape>,
+	sessionKey?: string,
+): AsyncIterable<StreamEventShape> {
+	let sawTerminalResponse = false;
+	const completedOutputItems = new Set<string>();
+	const outputItemKey = (item: unknown, index?: number): string | undefined => {
+		if (!item || typeof item !== "object") return undefined;
+		const candidate = item as { id?: unknown; type?: unknown };
+		if (typeof candidate.id === "string" && typeof candidate.type === "string") return `${candidate.type}:${candidate.id}`;
+		return typeof candidate.type === "string" && typeof index === "number" ? `${candidate.type}:index:${index}` : undefined;
+	};
+	for await (const event of events) {
+		const type = typeof event.type === "string" ? event.type : undefined;
+		if (!type) continue;
+
+		if (type === "response.metadata" && sessionKey) {
+			const eventHeaders = event.headers && typeof event.headers === "object" && !Array.isArray(event.headers)
+				? (event.headers as Record<string, unknown>)
+				: undefined;
+			const turnState = eventHeaders?.["x-codex-turn-state"];
+			if (typeof turnState === "string") {
+				captureCodexTurnState(sessionKey, turnState);
+			}
+		}
+
+		if (type === "error") {
+			const nestedError = event.error;
+			const status = typeof event.status === "number"
+				? event.status
+				: typeof event.status_code === "number"
+					? event.status_code
+					: undefined;
+			const eventHeaders = event.headers && typeof event.headers === "object" && !Array.isArray(event.headers)
+				? Object.fromEntries(
+						Object.entries(event.headers as Record<string, unknown>)
+							.filter((entry): entry is [string, string | number | boolean] =>
+								typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean")
+							.map(([name, value]) => [name, String(value)]),
+					)
+				: undefined;
+			const code = typeof nestedError?.code === "string"
+				? nestedError.code
+				: typeof event.code === "string"
+					? event.code
+					: undefined;
+			const message = typeof nestedError?.message === "string"
+				? nestedError.message
+				: typeof event.message === "string"
+					? event.message
+					: undefined;
+			const displayMessage = friendlyUsageLimitMessage(nestedError, status)
+				?? `Codex error: ${message || code || JSON.stringify(event)}`;
+			const error = new ProviderResponseError(displayMessage) as ProviderResponseError & {
+				sequenceNumber?: number;
+			};
+			if (code) error.code = code;
+			if (typeof nestedError?.type === "string") error.errorType = nestedError.type;
+			if (status !== undefined) error.status = status;
+			error.retryAfterMs = retryAfterMsFromHeaders(eventHeaders);
+			if (typeof event.sequence_number === "number") error.sequenceNumber = event.sequence_number;
+			throw error;
+		}
+
+		if (type === "response.failed") {
+			const responseError = event.response?.error as { code?: unknown; message?: unknown } | undefined;
+			const error = new ProviderResponseError(
+				typeof responseError?.message === "string" ? responseError.message : "OpenAI Responses request failed",
+			);
+			if (typeof responseError?.code === "string") error.code = responseError.code;
+			throw error;
+		}
+
+		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
+			sawTerminalResponse = true;
+			const response = event.response;
+			const output = Array.isArray(response?.output) ? response.output : [];
+			for (let outputIndex = 0; outputIndex < output.length; outputIndex++) {
+				const item = output[outputIndex];
+				if (!item || typeof item !== "object") continue;
+				const itemType = (item as { type?: unknown }).type;
+				if (
+					itemType !== "image_generation_call"
+					&& itemType !== "web_search_call"
+					&& itemType !== "compaction"
+					&& itemType !== "context_compaction"
+				) continue;
+				const key = outputItemKey(item, outputIndex);
+				if (key && completedOutputItems.has(key)) continue;
+				if (key) completedOutputItems.add(key);
+				yield { type: "response.output_item.done", output_index: outputIndex, item } as StreamEventShape;
+			}
+			yield {
+				...event,
+				type: "response.completed",
+				response: response ? { ...response, status: normalizeCodexStatus(response.status) } : response,
+			};
+			return;
+		}
+
+		if (type === "response.output_item.done") {
+			const key = outputItemKey(event.item, typeof event.output_index === "number" ? event.output_index : undefined);
+			if (key) completedOutputItems.add(key);
+		}
+
+		yield event;
+	}
+
+	if (!sawTerminalResponse) {
+		throw new Error("Stream closed before response.completed");
+	}
+}
+
+function normalizeCodexStatus(status: string | undefined): string | undefined {
+	if (typeof status !== "string") return undefined;
+	return CODEX_RESPONSE_STATUSES.has(status) ? status : undefined;
+}

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

@@ -0,0 +1,224 @@
+import { type ProviderHeaders } from "@earendil-works/pi-ai";
+import { type Api, type Model } from "@earendil-works/pi-ai/compat";
+import { type CodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { codexTurnStateFor, resolveCodexWireIdentity, type CodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { type ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { isProviderHeaderSuppressed, mergeProviderHeaders, providerHeaderDirective, setProviderDefaultHeader, setProviderGeneratedHeader } from "@oai404iao/pi-codex-runtime/internal/provider-headers";
+import { CODEX_REMOTE_COMPACTION_V2_FEATURE, OPENAI_BETA_RESPONSES_WEBSOCKETS, X_CODEX_BETA_FEATURES, X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE } from "./constants.js";
+import { buildCodexTurnMetadataJson } from "./request-metadata.js";
+import { dynamicImport } from "./runtime.js";
+
+let _os: { platform(): string; release(): string; arch(): string } | null = null;
+
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+	dynamicImport("node:os")
+		.then((module) => {
+			_os = module;
+		})
+		.catch(() => {
+			_os = null;
+		});
+}
+
+export function headersToRecord(headers: Headers): Record<string, string> {
+	return Object.fromEntries(headers.entries());
+}
+
+export function providerHeadersToHeaders(headers: ProviderHeaders): Headers {
+	const result = new Headers();
+	for (const [name, value] of Object.entries(headers)) {
+		if (typeof value === "string") result.set(name, value);
+	}
+	return result;
+}
+
+function buildBaseCodexHeaders(
+	modelHeaders: ProviderHeaders | undefined,
+	additionalHeaders: ProviderHeaders | undefined,
+	accountId: string | undefined,
+	token: string,
+): Headers {
+	const headers = mergeProviderHeaders(modelHeaders, additionalHeaders);
+	if (providerHeaderDirective(additionalHeaders, "authorization") === undefined && token) {
+		setProviderGeneratedHeader(headers, "Authorization", `Bearer ${token}`);
+	}
+	if (accountId) setProviderDefaultHeader(headers, "chatgpt-account-id", accountId);
+	setProviderDefaultHeader(headers, "originator", "pi");
+	setProviderDefaultHeader(
+		headers,
+		"User-Agent",
+		_os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)",
+	);
+	return headers;
+}
+
+/**
+ * Resolve the wire identity (UUID v7 session/thread/window) for a pi session
+ * and thread. Returns `undefined` when no pi session id is available so
+ * session-less requests keep their previous behavior.
+ */
+function wireIdentityFor(
+	sessionId: string | undefined,
+	threadId?: string,
+): { sessionId: string; threadId: string; windowId: string } | undefined {
+	if (!sessionId) return undefined;
+	return resolveCodexWireIdentity(sessionId, threadId || sessionId);
+}
+
+/** Inject the Codex-compatible identity headers for a session. */
+function applyWireIdentityHeaders(
+	headers: Headers,
+	sessionId: string | undefined,
+	threadId: string | undefined,
+	requestIdentity?: CodexRequestIdentity,
+): void {
+	const wire = requestIdentity ?? wireIdentityFor(sessionId, threadId);
+	if (!wire) return;
+	setProviderGeneratedHeader(headers, "session-id", wire.sessionId);
+	setProviderGeneratedHeader(headers, "thread-id", wire.threadId);
+	setProviderGeneratedHeader(headers, "x-codex-window-id", wire.windowId);
+	setProviderGeneratedHeader(headers, "x-client-request-id", wire.threadId);
+	const turnState = requestIdentity?.turnState
+		?? (sessionId ? codexTurnStateFor(sessionId) : undefined);
+	if (turnState) {
+		setProviderGeneratedHeader(headers, "x-codex-turn-state", turnState);
+	}
+	if (requestIdentity?.parentThreadId) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-codex-parent-thread-id",
+			requestIdentity.parentThreadId,
+		);
+	}
+	if (requestIdentity?.subagentKind) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-openai-subagent",
+			requestIdentity.subagentKind,
+		);
+	}
+	if (requestIdentity) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-codex-turn-metadata",
+			buildCodexTurnMetadataJson(requestIdentity),
+		);
+	}
+}
+
+/** Codex identity headers for an SSE request (exported for tests). */
+export function buildSSEHeaders(
+	modelHeaders: ProviderHeaders | undefined,
+	additionalHeaders: ProviderHeaders | undefined,
+	accountId: string | undefined,
+	token: string,
+	sessionId: string | undefined,
+	profile: CodexRequestProfile,
+	threadId?: string,
+	requestIdentity?: CodexRequestIdentity,
+): Headers {
+	const headers = buildBaseCodexHeaders(modelHeaders, additionalHeaders, accountId, token);
+	setProviderDefaultHeader(headers, "OpenAI-Beta", "responses=experimental");
+	setProviderDefaultHeader(headers, "accept", "text/event-stream");
+	setProviderDefaultHeader(headers, "content-type", "application/json");
+	if (profile.responsesMode === "lite") {
+		setProviderDefaultHeader(headers, X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE, "true");
+	}
+
+	applyWireIdentityHeaders(headers, sessionId, threadId, requestIdentity);
+
+	return headers;
+}
+
+function appendCommaSeparatedHeader(headers: Headers, name: string, value: string): void {
+	if (isProviderHeaderSuppressed(headers, name)) return;
+	const values = (headers.get(name) ?? "")
+		.split(",")
+		.map((entry) => entry.trim())
+		.filter(Boolean);
+	if (!values.includes(value)) headers.set(name, [...values, value].join(","));
+}
+
+export function applyConfiguredResponsesFeatureHeaders(
+	headers: Headers,
+	settings: ResolvedCodexModelSettings,
+	_model: Model<Api>,
+): Headers {
+	if (settings.compactionMode === "responses") {
+		appendCommaSeparatedHeader(
+			headers,
+			X_CODEX_BETA_FEATURES,
+			CODEX_REMOTE_COMPACTION_V2_FEATURE,
+		);
+	}
+	return headers;
+}
+
+export function buildWebSocketHeaders(
+	modelHeaders: ProviderHeaders | undefined,
+	additionalHeaders: ProviderHeaders | undefined,
+	accountId: string | undefined,
+	token: string,
+	sessionId: string,
+	threadId = sessionId,
+	requestIdentity?: CodexRequestIdentity,
+): Headers {
+	const headers = buildBaseCodexHeaders(modelHeaders, additionalHeaders, accountId, token);
+	headers.delete("accept");
+	headers.delete("content-type");
+	headers.delete("OpenAI-Beta");
+	headers.delete("openai-beta");
+	setProviderDefaultHeader(headers, "OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+	setProviderDefaultHeader(headers, "x-client-request-id", threadId);
+	setProviderDefaultHeader(headers, "session-id", sessionId);
+	setProviderDefaultHeader(headers, "thread-id", threadId);
+	const wire = requestIdentity ?? wireIdentityFor(sessionId, threadId);
+	if (wire) {
+		setProviderGeneratedHeader(headers, "session-id", wire.sessionId);
+		setProviderGeneratedHeader(headers, "thread-id", wire.threadId);
+		setProviderGeneratedHeader(headers, "x-codex-window-id", wire.windowId);
+		setProviderGeneratedHeader(headers, "x-client-request-id", wire.threadId);
+	}
+	if (requestIdentity?.parentThreadId) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-codex-parent-thread-id",
+			requestIdentity.parentThreadId,
+		);
+	}
+	if (requestIdentity?.subagentKind) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-openai-subagent",
+			requestIdentity.subagentKind,
+		);
+	}
+	if (requestIdentity) {
+		setProviderGeneratedHeader(
+			headers,
+			"x-codex-turn-metadata",
+			buildCodexTurnMetadataJson(requestIdentity),
+		);
+	}
+	return headers;
+}
+
+export function buildJsonHeaders(
+	modelHeaders: ProviderHeaders | undefined,
+	additionalHeaders: ProviderHeaders | undefined,
+	accountId: string | undefined,
+	apiKey: string,
+	sessionId?: string,
+	requestIdentity?: CodexRequestIdentity,
+): Headers {
+	const headers = buildBaseCodexHeaders(modelHeaders, additionalHeaders, accountId, apiKey);
+	setProviderDefaultHeader(headers, "accept", "application/json");
+	setProviderDefaultHeader(headers, "content-type", "application/json");
+	applyWireIdentityHeaders(
+		headers,
+		sessionId,
+		requestIdentity?.threadId ?? sessionId,
+		requestIdentity,
+	);
+	return headers;
+}

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

@@ -0,0 +1,24 @@
+import { type CodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { WS_RESPONSES_LITE_CLIENT_METADATA_KEY } from "./constants.js";
+
+export function stripResponsesLiteImageDetails(value: unknown): void {
+	if (Array.isArray(value)) {
+		for (const item of value) stripResponsesLiteImageDetails(item);
+		return;
+	}
+	if (!value || typeof value !== "object") return;
+	const record = value as Record<string, unknown>;
+	if (record.type === "input_image") delete record.detail;
+	for (const entry of Object.values(record)) stripResponsesLiteImageDetails(entry);
+}
+
+export function withResponsesLiteWebSocketMetadata<T extends { client_metadata?: Record<string, string> }>(body: T, responsesMode: CodexRequestProfile["responsesMode"]): T {
+	if (responsesMode !== "lite") return body;
+	return {
+		...body,
+		client_metadata: {
+			...body.client_metadata,
+			[WS_RESPONSES_LITE_CLIENT_METADATA_KEY]: "true",
+		},
+	};
+}

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

@@ -0,0 +1,33 @@
+import { type Api, type AssistantMessage, type Model } from "@earendil-works/pi-ai/compat";
+import { buildProviderErrorMessage } from "./errors.js";
+
+export function createInitialAssistantMessage<TApi extends Api>(model: Model<TApi>): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+}
+
+export function createErrorMessage(message: AssistantMessage, error: unknown, aborted: boolean): AssistantMessage {
+	for (const block of message.content) {
+		if (typeof block === "object" && block !== null && "partialJson" in block) {
+			delete (block as { partialJson?: string }).partialJson;
+		}
+	}
+	message.stopReason = aborted ? "aborted" : "error";
+	message.errorMessage = buildProviderErrorMessage(error);
+	return message;
+}

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

@@ -0,0 +1,76 @@
+import { WEBSOCKET_CONNECT_TIMEOUT_MS, WEBSOCKET_SEND_TIMEOUT_MS } from "./constants.js";
+import { prepareWebSocketRequestBodyForWire } from "./continuation.js";
+import { mapCodexEvents } from "./events.js";
+import { withWebSocketRequestMetadata } from "./request-metadata.js";
+import { type ResponsesBody, type WebSocketPrewarmRequest } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { parseWebSocket, sendWebSocketRequest } from "./websocket-events.js";
+import { acquireWebSocket } from "./websocket-session.js";
+
+export async function prewarmWebSocket(request: WebSocketPrewarmRequest): Promise<void> {
+	if ((request.body.input?.length ?? 0) > 0) {
+		throw new Error("Startup WebSocket prewarm must not include conversation input");
+	}
+	const acquired = await acquireWebSocket(
+		request.url,
+		request.headers,
+		request.cacheKey,
+		request.requestMetadata.sessionId,
+		request.signal,
+		request.connectTimeoutMs ?? WEBSOCKET_CONNECT_TIMEOUT_MS,
+	);
+	const { socket, entry } = acquired;
+	let keepConnection = true;
+	let released = false;
+	const releaseOnce = (options?: { keep?: boolean }) => {
+		if (released) return;
+		released = true;
+		acquired.release(options);
+	};
+
+	try {
+		const fullBody = withWebSocketRequestMetadata(request.body, request.requestMetadata);
+		const prewarmBody: ResponsesBody = {
+			...fullBody,
+			generate: false,
+		};
+		// A startup prewarm is the root of a new session continuation. Never
+		// chain another generate:false request from an existing response.
+		if (entry?.continuation) entry.continuation = undefined;
+		const requestBody = prewarmBody;
+		const wireBody = prepareWebSocketRequestBodyForWire(requestBody);
+		if (request.signal?.aborted) throw new Error("Request was aborted");
+		await sendWebSocketRequest(
+			socket,
+			JSON.stringify({ type: "response.create", ...wireBody }),
+			request.signal,
+			WEBSOCKET_SEND_TIMEOUT_MS,
+		);
+		const responseItems: unknown[] = [];
+		let responseId: string | undefined;
+		for await (const event of mapCodexEvents(parseWebSocket(socket, request.signal), request.requestMetadata.sessionId)) {
+			if (event.type === "response.created" && event.response?.id) responseId = event.response.id;
+			if (event.type === "response.output_item.done" && event.item) responseItems.push(event.item);
+			if (
+				(event.type === "response.completed" || event.type === "response.incomplete")
+				&& event.response?.id
+			) {
+				responseId = event.response.id;
+			}
+		}
+		if (entry && responseId) {
+			entry.continuation = {
+				lastRequestBody: prewarmBody,
+				lastResponseId: responseId,
+				lastResponseItems: responseItems,
+			};
+		}
+		releaseOnce({ keep: true });
+	} catch (error) {
+		keepConnection = false;
+		if (entry) entry.continuation = undefined;
+		releaseOnce({ keep: false });
+		throw error;
+	} finally {
+		releaseOnce({ keep: keepConnection });
+	}
+}

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

@@ -0,0 +1,55 @@
+import { ProxyAgent, type Dispatcher } from "undici";
+
+function envFirst(names: string[]): string | undefined {
+	if (typeof process === "undefined") return undefined;
+	for (const name of names) {
+		const value = process.env[name];
+		if (value?.trim()) return value.trim();
+	}
+	return undefined;
+}
+
+function noProxyMatches(hostname: string, noProxy: string | undefined): boolean {
+	if (!noProxy) return false;
+	const host = hostname.toLowerCase();
+	for (const rawPart of noProxy.split(",")) {
+		const part = rawPart.trim().toLowerCase();
+		if (!part) continue;
+		if (part === "*") return true;
+		const normalized = part.startsWith(".") ? part.slice(1) : part;
+		if (host === normalized || host.endsWith(`.${normalized}`)) return true;
+	}
+	return false;
+}
+
+export function proxyForWebSocketUrl(rawUrl: string): string | undefined {
+	let url: URL;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return undefined;
+	}
+	const noProxy = envFirst(["NO_PROXY", "no_proxy"]);
+	if (noProxyMatches(url.hostname, noProxy)) return undefined;
+	if (url.protocol === "wss:" || url.protocol === "https:") {
+		return envFirst(["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"]);
+	}
+	if (url.protocol === "ws:" || url.protocol === "http:") {
+		return envFirst(["HTTP_PROXY", "http_proxy", "HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"]);
+	}
+	return undefined;
+}
+
+export async function proxyDispatcherForUrl(rawUrl: string): Promise<Dispatcher | undefined> {
+	const proxy = proxyForWebSocketUrl(rawUrl);
+	if (!proxy) return undefined;
+	return new ProxyAgent(proxy);
+}
+
+export async function webSocketOptionsForUrl(url: string, headers: Record<string, string>): Promise<{
+	headers: Record<string, string>;
+	dispatcher?: Dispatcher;
+}> {
+	const dispatcher = await proxyDispatcherForUrl(url);
+	return dispatcher ? { headers, dispatcher } : { headers };
+}