Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

codex: support websocket continuation

Raine Virta4e0cf89c2ce4
diff --git a/README.md b/README.md
index 9f5fc2b..173fe59 100644
--- a/README.md
+++ b/README.md
@@ -529,9 +529,17 @@ affecting other keys.
Codex uses the WebSocket Responses transport by default. Set
`CCP_CODEX_TRANSPORT=http` to use the older HTTP SSE transport for debugging or
compatibility, or `CCP_CODEX_TRANSPORT=auto` to try WebSocket with HTTP fallback
-before any upstream event is exposed. `CCP_CODEX_PREVIOUS_RESPONSE_ID=1` enables
-WebSocket continuation for append-only turns. Continuation reduces repeated
-request upload size, but it does not increase the upstream model context window.
+only when setup fails before a request is sent upstream.
+`CCP_CODEX_PREVIOUS_RESPONSE_ID=1` enables opt-in WebSocket continuation for
+append-only turns. Continuation keeps in-memory state keyed by Claude Code
+session id, reuses a session WebSocket while it remains open, and sends
+`previous_response_id` only when the translated request shape is unchanged and
+the new input strictly extends the previous transcript. On mismatch, missing
+state, missing upstream response, closed connections, or setup failure, the
+proxy clears unsafe continuation state and sends the full request instead.
+Continuation reduces repeated request upload size, but it does not increase the
+upstream model context window. Multi-process or load-balanced deployments need
+sticky sessions or shared state before enabling continuation.
### Files
diff --git a/src/providers/codex/client.ts b/src/providers/codex/client.ts
index 2604757..39535e7 100644
--- a/src/providers/codex/client.ts
+++ b/src/providers/codex/client.ts
@@ -1,5 +1,11 @@
import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts";
-import { codexBaseUrl, codexOriginator, codexTransport, codexUserAgent } from "../../config.ts";
+import {
+ codexBaseUrl,
+ codexOriginator,
+ codexPreviousResponseId,
+ codexTransport,
+ codexUserAgent,
+} from "../../config.ts";
declare const BUILD_VERSION: string | undefined;
const PROXY_VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev";
import { forceRefresh, getAuth } from "./auth/manager.ts";
@@ -13,8 +19,10 @@ import {
CodexWebSocketSetupError,
codexWebSocketHeaders,
codexWebSocketRequest,
+ invalidateCodexWebSocketPoolKey,
+ isPreviousResponseMissingError,
} from "./websocket.ts";
-import type { ContinuationCandidate } from "./continuation.ts";
+import { clearContinuation, type ContinuationCandidate } from "./continuation.ts";
const FETCH_WATCHDOG_INTERVAL_MS = 30_000;
let fetchHeaderTimeoutMs = 60_000;
@@ -33,6 +41,7 @@ export interface CodexResponse {
export interface PostCodexOptions {
continuation?: ContinuationCandidate;
+ poolKey?: string;
}
export async function postCodex(
@@ -100,6 +109,7 @@ async function attemptPostCodex(
if (err.status === 429) {
throw new CodexError(429, "Rate limited", err.message, { retryAfter: err.retryAfter });
}
+ if (err.requestSent) throw err;
if (err.status !== 401 && err.status !== 403) throw err;
log.warn("codex websocket auth failed, refreshing token", { status: err.status });
auth = await forceRefresh();
@@ -150,11 +160,19 @@ async function doFetch(
opts: PostCodexOptions,
): Promise<Response> {
const mode = codexTransport();
- if (mode === "websocket") return doFetchWebSocket(accessToken, accountId, body, ctx, log, opts);
+ const continuationEnabled = codexPreviousResponseId();
+ const websocketOpts = {
+ ...opts,
+ poolKey: continuationEnabled ? ctx.sessionId : undefined,
+ };
+ if (mode === "websocket") {
+ return doFetchWebSocket(accessToken, accountId, body, ctx, log, websocketOpts);
+ }
if (mode === "auto") {
try {
- return await doFetchWebSocket(accessToken, accountId, body, ctx, log, opts);
+ return await doFetchWebSocket(accessToken, accountId, body, ctx, log, websocketOpts);
} catch (err) {
+ if (err instanceof CodexWebSocketSetupError && err.requestSent) throw err;
log.warn("codex websocket failed before response, falling back to http", {
err: String(err),
});
@@ -234,14 +252,34 @@ async function doFetchWebSocket(
size,
});
const startedAt = Date.now();
- const stream = await codexWebSocketRequest({
- url: codexUrl,
- headers,
- body: wsBody,
- ctx,
- connectTimeoutMs: 15_000,
- idleTimeoutMs: 300_000,
- });
+ let stream: ReadableStream<Uint8Array>;
+ try {
+ stream = await codexWebSocketRequest({
+ url: codexUrl,
+ headers,
+ body: wsBody,
+ ctx,
+ connectTimeoutMs: 15_000,
+ idleTimeoutMs: 300_000,
+ poolKey: opts.poolKey,
+ });
+ } catch (err) {
+ if (!isSafeFullWebSocketRetry(err, continuation)) throw err;
+ clearContinuation(ctx.sessionId);
+ invalidateCodexWebSocketPoolKey(opts.poolKey);
+ log.warn("codex previous response missing, retrying full websocket request", {
+ previousResponseId: continuation?.previousResponseId,
+ });
+ stream = await codexWebSocketRequest({
+ url: codexUrl,
+ headers,
+ body: toWebSocketRequest(body),
+ ctx,
+ connectTimeoutMs: 15_000,
+ idleTimeoutMs: 300_000,
+ poolKey: opts.poolKey,
+ });
+ }
const elapsedMs = Date.now() - startedAt;
const responseHeaders = new Headers({ "content-type": "text/event-stream" });
ctx.traffic?.writeJson("030-upstream-response-headers", {
@@ -340,6 +378,14 @@ async function safeText(resp: Response): Promise<string> {
}
}
+function isSafeFullWebSocketRetry(
+ err: unknown,
+ continuation: ContinuationCandidate | undefined,
+): boolean {
+ if (!continuation?.previousResponseId) return false;
+ return isPreviousResponseMissingError(err);
+}
+
export class CodexHeaderTimeoutError extends Error {
constructor(public timeoutMs: number) {
super(`Timed out waiting ${timeoutMs}ms for Codex response headers`);
diff --git a/src/providers/codex/continuation.test.ts b/src/providers/codex/continuation.test.ts
index 2cdeda5..0610bde 100644
--- a/src/providers/codex/continuation.test.ts
+++ b/src/providers/codex/continuation.test.ts
@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it } from "bun:test";
import {
clearAllContinuationsForTests,
continuationCandidate,
+ hasContinuationForTests,
recordContinuation,
} from "./continuation.ts";
import type { ResponsesInputItem, ResponsesRequest } from "./translate/request.ts";
@@ -68,7 +69,7 @@ describe("continuationCandidate", () => {
const second = requestWithInput(first.input, { tool_choice: "none" });
expect(continuationCandidate("s1", second, true).disabledReason).toBe("prompt_changed");
- expect(continuationCandidate("s1", second, true).disabledReason).toBe("missing_state");
+ expect(hasContinuationForTests("s1")).toBe(false);
});
it("preserves state when an exact repeat has no input delta", () => {
@@ -102,6 +103,7 @@ describe("continuationCandidate", () => {
]);
expect(continuationCandidate("s1", second, true).disabledReason).toBe("not_append_only");
+ expect(hasContinuationForTests("s1")).toBe(false);
});
it("handles previous function call output as visible transcript", () => {
@@ -138,6 +140,29 @@ describe("continuationCandidate", () => {
]);
});
+ it("expires stale state", () => {
+ const first = requestWithInput([
+ { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
+ ]);
+ recordContinuation("s1", first, "resp_1", [], 1_000);
+
+ expect(continuationCandidate("s1", first, true, 31 * 60 * 1_000).disabledReason).toBe(
+ "missing_state",
+ );
+ expect(hasContinuationForTests("s1")).toBe(false);
+ });
+
+ it("clears state when the response id is missing", () => {
+ const first = requestWithInput([
+ { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
+ ]);
+ recordContinuation("s1", first, "resp_1", []);
+
+ recordContinuation("s1", first, undefined, []);
+
+ expect(hasContinuationForTests("s1")).toBe(false);
+ });
+
it("does not store oversized session transcripts", () => {
const largeText = "x".repeat(2_000_001);
const first = requestWithInput([
diff --git a/src/providers/codex/continuation.ts b/src/providers/codex/continuation.ts
index e39ab6a..0d53a9e 100644
--- a/src/providers/codex/continuation.ts
+++ b/src/providers/codex/continuation.ts
@@ -62,7 +62,11 @@ export function recordContinuation(
outputItems: ResponsesInputItem[],
now = Date.now(),
): void {
- if (!sessionId || !responseId) return;
+ if (!sessionId) return;
+ if (!responseId) {
+ clearContinuation(sessionId);
+ return;
+ }
const transcript = [...requestBody.input, ...outputItems];
const transcriptBytes = byteLength(JSON.stringify(transcript));
if (transcriptBytes > MAX_SESSION_TRANSCRIPT_BYTES) {
@@ -88,6 +92,10 @@ export function clearContinuation(sessionId: string | undefined): void {
states.delete(sessionId);
}
+export function hasContinuationForTests(sessionId: string): boolean {
+ return states.has(sessionId);
+}
+
export function clearAllContinuationsForTests(): void {
states.clear();
totalTranscriptBytes = 0;
diff --git a/src/providers/codex/websocket.test.ts b/src/providers/codex/websocket.test.ts
index 0347318..8f8b26b 100644
--- a/src/providers/codex/websocket.test.ts
+++ b/src/providers/codex/websocket.test.ts
@@ -1,9 +1,10 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
import { createServer } from "node:http";
import WebSocket, { WebSocketServer } from "ws";
import type { RequestContext } from "../types.ts";
import {
CodexWebSocketSetupError,
+ clearCodexWebSocketPoolForTests,
codexWebSocketHeaders,
codexWebSocketRequest,
toWebSocketUrl,
@@ -27,6 +28,10 @@ function ctx(): RequestContext {
};
}
+afterEach(() => {
+ clearCodexWebSocketPoolForTests();
+});
+
function body(): ResponsesWebSocketRequest {
return {
model: "gpt-5.5",
@@ -48,17 +53,26 @@ async function collect(stream: ReadableStream<Uint8Array>): Promise<string> {
}
async function withServer(
- handler: (socket: WebSocket, requestBody: Promise<unknown>) => void,
+ handler: (socket: WebSocket, requestBody: Promise<unknown>, request: import("node:http").IncomingMessage) => void,
): Promise<{ url: string; close: () => Promise<void> }> {
const server = createServer();
const wss = new WebSocketServer({ server });
- wss.on("connection", (socket) => {
- let resolveBody: (value: unknown) => void = () => {};
- const requestBody = new Promise<unknown>((resolve) => {
- resolveBody = resolve;
+ wss.on("connection", (socket, request) => {
+ const messages: unknown[] = [];
+ const waiters: ((value: unknown) => void)[] = [];
+ const nextBody = () =>
+ new Promise<unknown>((resolve) => {
+ const message = messages.shift();
+ if (message !== undefined) resolve(message);
+ else waiters.push(resolve);
+ });
+ socket.on("message", (data) => {
+ const message = JSON.parse(data.toString());
+ const waiter = waiters.shift();
+ if (waiter) waiter(message);
+ else messages.push(message);
});
- socket.once("message", (data) => resolveBody(JSON.parse(data.toString())));
- handler(socket, requestBody);
+ handler(socket, nextBody(), request);
});
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
const address = server.address();
@@ -154,7 +168,40 @@ describe("Codex WebSocket helpers", () => {
);
});
try {
- await expect(
+ let caught: unknown;
+ try {
+ await codexWebSocketRequest({
+ url: server.url,
+ headers: new Headers(),
+ body: body(),
+ ctx: ctx(),
+ connectTimeoutMs: 1_000,
+ idleTimeoutMs: 1_000,
+ });
+ } catch (err) {
+ caught = err;
+ }
+ expect(caught).toBeInstanceOf(CodexWebSocketSetupError);
+ const err = caught as CodexWebSocketSetupError;
+ expect(err.status).toBe(429);
+ expect(err.code).toBe("rate_limit");
+ expect(err.retryAfter).toBe("3");
+ expect(err.requestSent).toBe(false);
+ } finally {
+ await server.close();
+ }
+ });
+
+ it("reuses a pooled websocket", async () => {
+ let sockets = 0;
+ const server = await withServer((socket) => {
+ sockets++;
+ socket.on("message", () => {
+ socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${sockets}` } }));
+ });
+ });
+ try {
+ const request = () =>
codexWebSocketRequest({
url: server.url,
headers: new Headers(),
@@ -162,13 +209,41 @@ describe("Codex WebSocket helpers", () => {
ctx: ctx(),
connectTimeoutMs: 1_000,
idleTimeoutMs: 1_000,
- }),
- ).rejects.toMatchObject({
- name: "CodexWebSocketSetupError",
- status: 429,
- code: "rate_limit",
- retryAfter: "3",
+ poolKey: "session-1",
+ });
+
+ await collect(await request());
+ await collect(await request());
+
+ expect(sockets).toBe(1);
+ } finally {
+ clearCodexWebSocketPoolForTests();
+ await server.close();
+ }
+ });
+
+ it("does not pool websocket requests without a pool key", async () => {
+ let sockets = 0;
+ const server = await withServer((socket) => {
+ sockets++;
+ socket.on("message", () => {
+ socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${sockets}` } }));
});
+ });
+ try {
+ const makeRequest = () =>
+ codexWebSocketRequest({
+ url: server.url,
+ headers: new Headers(),
+ body: body(),
+ ctx: ctx(),
+ connectTimeoutMs: 1_000,
+ idleTimeoutMs: 1_000,
+ }).then(collect);
+
+ await makeRequest();
+ await makeRequest();
+ expect(sockets).toBe(2);
} finally {
await server.close();
}
diff --git a/src/providers/codex/websocket.ts b/src/providers/codex/websocket.ts
index ac75fb1..9c0f363 100644
--- a/src/providers/codex/websocket.ts
+++ b/src/providers/codex/websocket.ts
@@ -1,3 +1,4 @@
+import type { IncomingMessage } from "node:http";
import WebSocket from "ws";
import { headersToRecord } from "../../traffic.ts";
import type { RequestContext } from "../types.ts";
@@ -11,6 +12,7 @@ export class CodexWebSocketSetupError extends Error {
public status?: number,
public code?: string,
public retryAfter?: string,
+ public requestSent = false,
) {
super(message);
this.name = "CodexWebSocketSetupError";
@@ -24,6 +26,355 @@ export interface CodexWebSocketOptions {
ctx: RequestContext;
connectTimeoutMs: number;
idleTimeoutMs: number;
+ poolKey?: string;
+}
+
+export type CodexWebSocketInvalidateReason = "cancel" | "error" | "close";
+
+interface ActiveRequest {
+ controller?: ReadableStreamDefaultController<Uint8Array>;
+ pendingChunks: Uint8Array[];
+ resolve: (stream: ReadableStream<Uint8Array>) => void;
+ reject: (err: Error) => void;
+ settled: boolean;
+ done: boolean;
+ requestSent: boolean;
+ chunksExposed: boolean;
+ idleTimer?: ReturnType<typeof setTimeout>;
+ stream: ReadableStream<Uint8Array>;
+ ctx: RequestContext;
+ releaseQueue: () => void;
+}
+
+interface PoolEntry {
+ connection: CodexWebSocketConnection;
+ lastUsed: number;
+}
+
+class CodexWebSocketConnection {
+ private socket?: WebSocket;
+ private active?: ActiveRequest;
+ private activeAbort?: () => void;
+ private connectPromise?: Promise<void>;
+ private connectTimer?: ReturnType<typeof setTimeout>;
+ private closed = false;
+ private requestHeaders: Record<string, string>;
+ private queue: Promise<void> = Promise.resolve();
+
+ constructor(
+ private readonly wsUrl: string,
+ headers: Headers,
+ private readonly connectTimeoutMs: number,
+ private readonly idleTimeoutMs: number,
+ private readonly keepAlive: boolean,
+ private readonly onInvalidate?: (reason: CodexWebSocketInvalidateReason) => void,
+ ) {
+ this.requestHeaders = codexWebSocketHeaders(headers);
+ }
+
+ updateHeaders(headers: Headers): void {
+ this.requestHeaders = codexWebSocketHeaders(headers);
+ }
+
+ isClosed(): boolean {
+ return this.closed || !this.socket || this.socket.readyState === WebSocket.CLOSED;
+ }
+
+ hasActiveRequest(): boolean {
+ return !!this.active;
+ }
+
+ dispose(): void {
+ this.closed = true;
+ this.clearConnectTimer();
+ this.failActive(new Error("Codex WebSocket connection closed"));
+ this.socket?.on("error", () => {});
+ this.socket?.terminate();
+ }
+
+ async request(opts: CodexWebSocketOptions): Promise<ReadableStream<Uint8Array>> {
+ const previous = this.queue.catch(() => {});
+ let releaseQueue: () => void = () => {};
+ const queued = new Promise<void>((resolve) => {
+ releaseQueue = resolve;
+ });
+ this.queue = previous.then(() => queued);
+ await previous;
+ if (this.closed) {
+ releaseQueue();
+ throw new Error("Codex WebSocket connection closed");
+ }
+ if (opts.ctx.signal.aborted) {
+ releaseQueue();
+ throw new DOMException("Aborted", "AbortError");
+ }
+ try {
+ return await this.runRequest(opts, releaseQueue);
+ } catch (err) {
+ releaseQueue();
+ throw err;
+ }
+ }
+
+ private async runRequest(
+ opts: CodexWebSocketOptions,
+ releaseQueue: () => void,
+ ): Promise<ReadableStream<Uint8Array>> {
+ this.updateHeaders(opts.headers);
+ return new Promise((resolve, reject) => {
+ const pendingChunks: Uint8Array[] = [];
+ let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
+ let active: ActiveRequest;
+ const stream = new ReadableStream<Uint8Array>({
+ start: (next) => {
+ controller = next;
+ for (const chunk of pendingChunks.splice(0)) {
+ if (chunk.byteLength === 0) next.close();
+ else next.enqueue(chunk);
+ }
+ },
+ cancel: () => {
+ active.done = true;
+ this.clearIdle(active);
+ opts.ctx.signal.removeEventListener("abort", onAbort);
+ this.activeAbort = undefined;
+ this.active = undefined;
+ this.closed = true;
+ this.socket?.on("error", () => {});
+ this.socket?.terminate();
+ this.onInvalidate?.("cancel");
+ active.releaseQueue();
+ },
+ });
+ active = {
+ controller,
+ pendingChunks,
+ resolve,
+ reject,
+ settled: false,
+ done: false,
+ requestSent: false,
+ chunksExposed: false,
+ ctx: opts.ctx,
+ releaseQueue,
+ stream,
+ };
+ const onAbort = () => this.failActive(new DOMException("Aborted", "AbortError"));
+ opts.ctx.signal.addEventListener("abort", onAbort, { once: true });
+ this.active = active;
+ this.activeAbort = onAbort;
+ this.connect(opts.ctx)
+ .then(() => {
+ if (active.done) return;
+ this.resetIdle(active);
+ const { stream: _stream, ...payload } = opts.body;
+ if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+ throw new Error("Codex WebSocket is not open");
+ }
+ active.requestSent = true;
+ this.socket.send(JSON.stringify({ type: "response.create", ...payload }), (err) => {
+ if (err) this.failActive(err instanceof Error ? err : new Error(String(err)));
+ });
+ })
+ .catch((err) => this.failActive(err instanceof Error ? err : new Error(String(err))));
+ });
+ }
+
+ private connect(ctx: RequestContext): Promise<void> {
+ if (this.socket?.readyState === WebSocket.OPEN) return Promise.resolve();
+ if (this.connectPromise) return this.connectPromise;
+ this.closed = false;
+ this.connectPromise = new Promise((resolve, reject) => {
+ const socket = new WebSocket(this.wsUrl, { headers: this.requestHeaders });
+ this.socket = socket;
+ const cleanup = () => {
+ this.clearConnectTimer();
+ ctx.signal.removeEventListener("abort", onAbort);
+ this.connectPromise = undefined;
+ };
+ const failConnect = (err: Error) => {
+ this.closed = true;
+ cleanup();
+ socket.on("error", () => {});
+ socket.terminate();
+ reject(err);
+ };
+ const onAbort = () => failConnect(new DOMException("Aborted", "AbortError"));
+ this.connectTimer = setTimeout(
+ () => failConnect(new Error("Timed out connecting to Codex WebSocket")),
+ this.connectTimeoutMs,
+ );
+ ctx.signal.addEventListener("abort", onAbort, { once: true });
+ socket.on("upgrade", (_message: IncomingMessage) => {});
+ socket.on("unexpected-response", (_request, response) => {
+ failConnect(setupErrorFromResponse(response));
+ });
+ socket.on("open", () => {
+ cleanup();
+ resolve();
+ });
+ socket.on("message", (data, isBinary) => {
+ this.onMessage(data, isBinary);
+ });
+ socket.on("error", (err) => {
+ if (this.connectPromise) failConnect(err instanceof Error ? err : new Error(String(err)));
+ else this.failActive(err instanceof Error ? err : new Error(String(err)));
+ });
+ socket.on("close", (code, reason) => {
+ this.closed = true;
+ this.onInvalidate?.("close");
+ if (this.connectPromise) {
+ failConnect(new Error(`Codex WebSocket closed during setup: ${code} ${reason}`));
+ return;
+ }
+ if (this.active) {
+ this.failActive(
+ new CodexWebSocketSetupError(
+ `Codex WebSocket closed before terminal event: ${code} ${reason}`,
+ undefined,
+ undefined,
+ undefined,
+ this.active.requestSent,
+ ),
+ );
+ }
+ });
+ });
+ return this.connectPromise;
+ }
+
+ private onMessage(data: WebSocket.RawData, isBinary: boolean): void {
+ const active = this.active;
+ if (!active) return;
+ if (isBinary) {
+ this.failActive(new Error("Unexpected binary Codex WebSocket frame"));
+ return;
+ }
+ this.resetIdle(active);
+ const text = data.toString();
+ let event: {
+ type?: string;
+ status?: number;
+ status_code?: number;
+ error?: { code?: string; message?: string };
+ headers?: Record<string, string>;
+ };
+ try {
+ event = JSON.parse(text);
+ } catch (err) {
+ this.failActive(err instanceof Error ? err : new Error(String(err)));
+ return;
+ }
+ if (!active.settled && event.type === "error" && isSetupErrorEvent(event)) {
+ this.failActive(setupErrorFromEvent(event, active.requestSent));
+ return;
+ }
+ if (isPreviousResponseMissingEvent(event)) {
+ this.failActive(setupErrorFromEvent(event, active.requestSent));
+ return;
+ }
+ this.enqueue(active, new TextEncoder().encode(encodeSse(text)));
+ if (!active.settled) {
+ active.settled = true;
+ active.chunksExposed = true;
+ active.resolve(active.stream);
+ }
+ if (isTerminalEvent(event.type)) this.finishActive();
+ }
+
+ private resetIdle(active: ActiveRequest): void {
+ this.clearIdle(active);
+ active.idleTimer = setTimeout(
+ () => this.failActive(new Error("Timed out waiting for Codex WebSocket event")),
+ this.idleTimeoutMs,
+ );
+ }
+
+ private clearIdle(active: ActiveRequest): void {
+ if (active.idleTimer) clearTimeout(active.idleTimer);
+ active.idleTimer = undefined;
+ }
+
+ private clearConnectTimer(): void {
+ if (this.connectTimer) clearTimeout(this.connectTimer);
+ this.connectTimer = undefined;
+ }
+
+ private enqueue(active: ActiveRequest, chunk: Uint8Array): void {
+ if (active.controller) active.controller.enqueue(chunk);
+ else active.pendingChunks.push(chunk);
+ }
+
+ private finishActive(): void {
+ const active = this.active;
+ if (!active || active.done) return;
+ active.done = true;
+ this.clearIdle(active);
+ if (this.activeAbort) active.ctx.signal.removeEventListener("abort", this.activeAbort);
+ this.activeAbort = undefined;
+ this.active = undefined;
+ if (!this.keepAlive) this.socket?.close();
+ active.releaseQueue();
+ if (active.controller) active.controller.close();
+ else active.pendingChunks.push(new Uint8Array());
+ }
+
+ private failActive(err: Error): void {
+ const active = this.active;
+ if (!active || active.done) return;
+ active.done = true;
+ this.clearIdle(active);
+ if (this.activeAbort) active.ctx.signal.removeEventListener("abort", this.activeAbort);
+ this.activeAbort = undefined;
+ this.active = undefined;
+ active.releaseQueue();
+ if (err instanceof CodexWebSocketSetupError) err.requestSent = active.requestSent;
+ else if (active.requestSent) err = new CodexWebSocketSetupError(err.message, undefined, undefined, undefined, true);
+ if (active.requestSent) {
+ this.closed = true;
+ this.socket?.on("error", () => {});
+ this.socket?.terminate();
+ this.onInvalidate?.("error");
+ }
+ if (!active.settled) active.reject(err);
+ else active.controller?.error(err);
+ }
+
+}
+
+const POOL_IDLE_TTL_MS = 30 * 60 * 1000;
+const MAX_POOL_ENTRIES = 10_000;
+const pool = new Map<string, PoolEntry>();
+
+export function clearCodexWebSocketPoolForTests(): void {
+ for (const entry of pool.values()) entry.connection.dispose();
+ pool.clear();
+}
+
+export function invalidateCodexWebSocketPoolKey(poolKey: string | undefined): void {
+ if (!poolKey) return;
+ const entry = pool.get(poolKey);
+ if (!entry) return;
+ entry.connection.dispose();
+ pool.delete(poolKey);
+}
+
+function evictIdlePoolEntries(now = Date.now()): void {
+ for (const [key, entry] of pool) {
+ if (
+ (entry.connection.hasActiveRequest() || now - entry.lastUsed <= POOL_IDLE_TTL_MS) &&
+ !entry.connection.isClosed()
+ ) {
+ continue;
+ }
+ entry.connection.dispose();
+ pool.delete(key);
+ }
+ while (pool.size > MAX_POOL_ENTRIES) {
+ const key = pool.keys().next().value;
+ if (!key) return;
+ invalidateCodexWebSocketPoolKey(key);
+ }
}
export function toWebSocketUrl(url: string): string {
@@ -49,7 +400,6 @@ export function codexWebSocketHeaders(headers: Headers): Record<string, string>
export async function codexWebSocketRequest(
opts: CodexWebSocketOptions,
): Promise<ReadableStream<Uint8Array>> {
- const encoder = new TextEncoder();
const wsUrl = toWebSocketUrl(opts.url);
const requestHeaders = codexWebSocketHeaders(opts.headers);
@@ -57,150 +407,141 @@ export async function codexWebSocketRequest(
provider: "codex",
url: wsUrl,
headers: requestHeaders,
+ poolKey: opts.poolKey,
});
- return new Promise((resolve, reject) => {
- const socket = new WebSocket(wsUrl, { headers: requestHeaders });
- let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
- let settled = false;
- let done = false;
- let idleTimer: ReturnType<typeof setTimeout> | undefined;
- let connectTimer: ReturnType<typeof setTimeout> | undefined;
- const pendingChunks: Uint8Array[] = [];
-
- const stream = new ReadableStream<Uint8Array>({
- start(next) {
- controller = next;
- for (const chunk of pendingChunks.splice(0)) controller.enqueue(chunk);
- },
- cancel() {
- done = true;
- cleanup();
- socket.on("error", () => {});
- socket.terminate();
- },
- });
-
- const cleanup = () => {
- if (idleTimer) clearTimeout(idleTimer);
- if (connectTimer) clearTimeout(connectTimer);
- opts.ctx.signal.removeEventListener("abort", onAbort);
- };
- const fail = (err: Error) => {
- if (done) return;
- done = true;
- cleanup();
- socket.on("error", () => {});
- socket.terminate();
- if (!settled) reject(err);
- else controller?.error(err);
- };
- const enqueue = (chunk: Uint8Array) => {
- if (controller) controller.enqueue(chunk);
- else pendingChunks.push(chunk);
- };
- const closeController = () => {
- if (controller) controller.close();
- else queueMicrotask(closeController);
- };
- const close = () => {
- if (done) return;
- done = true;
- cleanup();
- closeController();
- socket.close();
- };
- const resetIdle = () => {
- if (idleTimer) clearTimeout(idleTimer);
- idleTimer = setTimeout(
- () => fail(new Error("Timed out waiting for Codex WebSocket event")),
- opts.idleTimeoutMs,
- );
- };
- const onAbort = () => fail(new DOMException("Aborted", "AbortError"));
- const encodeSse = (text: string) =>
- `${text
- .split(/\r?\n/)
- .map((line) => `data: ${line}`)
- .join("\n")}\n\n`;
-
- connectTimer = setTimeout(
- () => fail(new Error("Timed out connecting to Codex WebSocket")),
+ if (!opts.poolKey) {
+ const connection = new CodexWebSocketConnection(
+ wsUrl,
+ opts.headers,
opts.connectTimeoutMs,
+ opts.idleTimeoutMs,
+ false,
);
- opts.ctx.signal.addEventListener("abort", onAbort, { once: true });
-
- socket.on("open", () => {
- if (connectTimer) clearTimeout(connectTimer);
- resetIdle();
- const { stream: _stream, ...payload } = opts.body;
- try {
- socket.send(JSON.stringify({ type: "response.create", ...payload }), (err) => {
- if (err) fail(err instanceof Error ? err : new Error(String(err)));
- });
- } catch (err) {
- fail(err instanceof Error ? err : new Error(String(err)));
- }
- });
- socket.on("message", (data, isBinary) => {
- if (isBinary) {
- fail(new Error("Unexpected binary Codex WebSocket frame"));
- return;
- }
- resetIdle();
- const text = data.toString();
- let event: {
- type?: string;
- status?: number;
- error?: { code?: string; message?: string };
- headers?: Record<string, string>;
- };
- try {
- event = JSON.parse(text);
- } catch (err) {
- fail(err instanceof Error ? err : new Error(String(err)));
- return;
- }
- if (!settled && event.type === "error") {
- fail(
- new CodexWebSocketSetupError(
- event.error?.message ?? event.error?.code ?? "Codex WebSocket setup error",
- event.status,
- event.error?.code,
- event.headers?.["retry-after"],
- ),
- );
- return;
- }
- if (event.type === "error" && event.error?.message?.includes("Previous response with id")) {
- fail(
- new CodexWebSocketSetupError(
- event.error.message,
- event.status,
- event.error.code,
- event.headers?.["retry-after"],
- ),
- );
- return;
- }
- enqueue(encoder.encode(encodeSse(text)));
- if (!settled) {
- settled = true;
- resolve(stream);
- }
- if (
- event.type === "response.completed" ||
- event.type === "response.failed" ||
- event.type === "response.incomplete" ||
- event.type === "response.done" ||
- event.type === "error"
- ) {
- close();
+ try {
+ return await connection.request(opts);
+ } catch (err) {
+ connection.dispose();
+ throw err;
+ }
+ }
+
+ evictIdlePoolEntries();
+ const existing = pool.get(opts.poolKey);
+ if (existing && !existing.connection.isClosed()) {
+ existing.lastUsed = Date.now();
+ existing.connection.updateHeaders(opts.headers);
+ try {
+ return await existing.connection.request(opts);
+ } catch (err) {
+ if (err instanceof CodexWebSocketSetupError || isConnectionInvalidatingError(err)) {
+ invalidateCodexWebSocketPoolKey(opts.poolKey);
}
- });
- socket.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
- socket.on("close", (code, reason) => {
- if (!done) fail(new Error(`Codex WebSocket closed before terminal event: ${code} ${reason}`));
- });
- });
+ throw err;
+ }
+ }
+
+ if (existing) invalidateCodexWebSocketPoolKey(opts.poolKey);
+ const connection = new CodexWebSocketConnection(
+ wsUrl,
+ opts.headers,
+ opts.connectTimeoutMs,
+ opts.idleTimeoutMs,
+ true,
+ () => pool.delete(opts.poolKey!),
+ );
+ pool.set(opts.poolKey, { connection, lastUsed: Date.now() });
+ try {
+ return await connection.request(opts);
+ } catch (err) {
+ if (err instanceof CodexWebSocketSetupError || isConnectionInvalidatingError(err)) {
+ invalidateCodexWebSocketPoolKey(opts.poolKey);
+ }
+ throw err;
+ }
+}
+
+export function isPreviousResponseMissingError(err: unknown): boolean {
+ if (!(err instanceof CodexWebSocketSetupError)) return false;
+ return isPreviousResponseMissingMessage(err.message) || err.code === "previous_response_not_found";
+}
+
+function isSetupErrorEvent(event: {
+ status?: number;
+ status_code?: number;
+ error?: { code?: string; message?: string };
+}): boolean {
+ const status = event.status ?? event.status_code;
+ return status === 401 || status === 403 || status === 429;
+}
+
+function isPreviousResponseMissingEvent(event: {
+ error?: { code?: string; message?: string };
+}): boolean {
+ return (
+ event.error?.code === "previous_response_not_found" ||
+ isPreviousResponseMissingMessage(event.error?.message)
+ );
+}
+
+function isPreviousResponseMissingMessage(message: string | undefined): boolean {
+ if (!message) return false;
+ const lower = message.toLowerCase();
+ return lower.includes("previous response") && lower.includes("not found");
+}
+
+function setupErrorFromEvent(
+ event: {
+ status?: number;
+ status_code?: number;
+ error?: { code?: string; message?: string };
+ headers?: Record<string, string>;
+ },
+ requestSent: boolean,
+): CodexWebSocketSetupError {
+ return new CodexWebSocketSetupError(
+ event.error?.message ?? event.error?.code ?? "Codex WebSocket setup error",
+ event.status ?? event.status_code,
+ event.error?.code,
+ event.headers?.["retry-after"],
+ requestSent,
+ );
+}
+
+function setupErrorFromResponse(response: IncomingMessage): CodexWebSocketSetupError {
+ const status = response.statusCode;
+ const retryAfter = headerValue(response.headers["retry-after"]);
+ return new CodexWebSocketSetupError(
+ `Codex WebSocket upgrade failed${status ? ` with status ${status}` : ""}`,
+ status,
+ undefined,
+ retryAfter,
+ false,
+ );
+}
+
+function headerValue(value: string | string[] | undefined): string | undefined {
+ return Array.isArray(value) ? value[0] : value;
+}
+
+function isConnectionInvalidatingError(err: unknown): boolean {
+ if (!(err instanceof Error)) return false;
+ return err.message.includes("closed") || err.message.includes("Timed out");
+}
+
+function isTerminalEvent(type: string | undefined): boolean {
+ return (
+ type === "response.completed" ||
+ type === "response.failed" ||
+ type === "response.incomplete" ||
+ type === "response.done" ||
+ type === "error"
+ );
+}
+
+function encodeSse(text: string): string {
+ return `${text
+ .split(/\r?\n/)
+ .map((line) => `data: ${line}`)
+ .join("\n")}\n\n`;
}