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.mdindex 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 orcompatibility, 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.### Filesdiff --git a/src/providers/codex/client.ts b/src/providers/codex/client.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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`;}