Skip to content

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

Rust

dedupe codex stream websocket tests

Raine Virta694e820d87bb
diff --git a/src/providers/codex/translate/stream.test.ts b/src/providers/codex/translate/stream.test.ts
index 5acf960..98949ec 100644
--- a/src/providers/codex/translate/stream.test.ts
+++ b/src/providers/codex/translate/stream.test.ts
@@ -12,97 +12,110 @@ import {
let now = 0;
const realNow = Date.now;
+async function withMockNow<T>(run: () => Promise<T>): Promise<T> {
+ Date.now = () => now;
+ try {
+ return await run();
+ } finally {
+ Date.now = realNow;
+ now = 0;
+ }
+}
+
+function readChunks(deltas: string[], includeDone = true): string[] {
+ return [
+ sse("response.output_item.added", {
+ output_index: 0,
+ item: { type: "function_call", call_id: "call_read", name: "Read" },
+ }),
+ ...deltas.map((delta) =>
+ sse("response.function_call_arguments.delta", { output_index: 0, delta }),
+ ),
+ ...(includeDone
+ ? [
+ sse("response.output_item.done", {
+ output_index: 0,
+ item: { type: "function_call", arguments: "{\"file_path\":\"/tmp/a\"}" },
+ }),
+ ]
+ : []),
+ ];
+}
+
+function collectFromChunks(
+ chunks: string[],
+ options?: {
+ advance?: () => void;
+ log?: typeof silentLog;
+ signal?: AbortSignal;
+ },
+): Promise<string> {
+ const upstream = options?.advance
+ ? upstreamFromChunks(chunks, options.advance)
+ : upstreamFromChunks(chunks);
+ return collect(
+ translateStream(upstream, {
+ messageId: "msg_1",
+ model: "gpt-5.5",
+ log: options?.log ?? silentLog,
+ ...(options?.signal ? { signal: options.signal } : {}),
+ }),
+ );
+}
+
describe("translateStream", () => {
it("emits keepalive pings while Read arguments are buffered", async () => {
- Date.now = () => now;
- try {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
- }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: "{\"file_path\"" }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: ":\"/tmp/a\"}" }),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "function_call", arguments: "{\"file_path\":\"/tmp/a\"}" },
- }),
- sse("response.completed", { response: { usage: {} } }),
- ];
-
- const output = await collect(
- translateStream(upstreamFromChunks(chunks, () => {
- now += 16_000;
- }), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- }),
- );
-
- expect(output).toContain("event: content_block_start");
- expect(output).toContain("event: content_block_delta");
- expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
- expect(output).toContain("event: message_stop");
- } finally {
- Date.now = realNow;
- now = 0;
- }
- });
+ const chunks = [
+ ...readChunks(["{\"file_path\"", "\":\"/tmp/a\"}"]),
+ sse("response.completed", { response: { usage: {} } }),
+ ];
- it("emits keepalive pings for upstream keepalive events", async () => {
- Date.now = () => now;
- try {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("keepalive", {}),
- sse("keepalive", {}),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { usage: {} } }),
- ];
-
- const output = await collect(
- translateStream(upstreamFromChunks(chunks, () => {
+ const output = await withMockNow(() =>
+ collectFromChunks(chunks, {
+ advance: () => {
now += 16_000;
- }), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- }),
- );
-
- expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
- expect(output).toContain("event: message_stop");
- } finally {
- Date.now = realNow;
- now = 0;
- }
+ },
+ }),
+ );
+
+ expect(output).toContain("event: content_block_start");
+ expect(output).toContain("event: content_block_delta");
+ expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
+ expect(output).toContain("event: message_stop");
});
- it("emits an error instead of message_stop when upstream ends with an open Read block", async () => {
+ it("emits keepalive pings for upstream keepalive events", async () => {
const chunks = [
sse("response.output_item.added", {
output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
+ item: { type: "message", id: "msg_upstream" },
}),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: "{\"file_path\"" }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: ":\"/tmp/a\"" }),
+ sse("keepalive", {}),
+ sse("keepalive", {}),
+ sse("response.output_item.done", {
+ output_index: 0,
+ item: { type: "message", id: "msg_upstream" },
+ }),
+ sse("response.completed", { response: { usage: {} } }),
];
- const output = await collect(
- translateStream(upstreamFromChunks(chunks), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
+ const output = await withMockNow(() =>
+ collectFromChunks(chunks, {
+ advance: () => {
+ now += 16_000;
+ },
}),
);
+ expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
+ expect(output).toContain("event: message_stop");
+ });
+
+ it("emits an error instead of message_stop when upstream ends with an open Read block", async () => {
+ const chunks = readChunks(["{\"file_path\"", ':"/tmp/a"'], false);
+
+ const output = await collectFromChunks(chunks);
+
expect(output).toContain("event: content_block_start");
expect(output).toContain("event: content_block_stop");
expect(output).toContain("event: error");
@@ -112,13 +125,7 @@ describe("translateStream", () => {
});
it("reports upstream read failures as upstream stream errors", async () => {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
- }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: "{\"file_path\"" }),
- ];
+ const chunks = readChunks(["{\"file_path\""], false);
const err = new DOMException("The connection was closed.", "AbortError");
const logs: Array<{ msg: string; fields: unknown }> = [];
const log = {
@@ -142,36 +149,21 @@ describe("translateStream", () => {
});
it("fails buffered Read arguments that exceed the safe duration", async () => {
- Date.now = () => now;
- try {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
- }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: "{\"file_path\"" }),
- sse("response.function_call_arguments.delta", { output_index: 0, delta: ":\"/tmp/a\"" }),
- ];
-
- const output = await collect(
- translateStream(upstreamFromChunks(chunks, () => {
+ const chunks = readChunks(["{\"file_path\"", ':"/tmp/a"'], false);
+
+ const output = await withMockNow(() =>
+ collectFromChunks(chunks, {
+ advance: () => {
now += 121_000;
- }), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- }),
- );
-
- expect(output).toContain("Buffered Read tool arguments exceeded safe limits");
- expect(output).toContain("event: content_block_stop");
- expect(output).toContain("event: error");
- expect(output).not.toContain("input_json_delta");
- expect(output).not.toContain("event: message_stop");
- } finally {
- Date.now = realNow;
- now = 0;
- }
+ },
+ }),
+ );
+
+ expect(output).toContain("Buffered Read tool arguments exceeded safe limits");
+ expect(output).toContain("event: content_block_stop");
+ expect(output).toContain("event: error");
+ expect(output).not.toContain("input_json_delta");
+ expect(output).not.toContain("event: message_stop");
});
it("treats aborted upstream reads as cancellation", async () => {
diff --git a/src/providers/codex/websocket.test.ts b/src/providers/codex/websocket.test.ts
index b326688..5eaadea 100644
--- a/src/providers/codex/websocket.test.ts
+++ b/src/providers/codex/websocket.test.ts
@@ -20,6 +20,11 @@ const silentLog = {
child: () => silentLog,
};
+const websocketTimeoutMs = {
+ connect: 1_000,
+ idle: 1_000,
+};
+
function ctx(): RequestContext {
return {
reqId: "req_1",
@@ -52,6 +57,21 @@ async function collect(stream: ReadableStream<Uint8Array>): Promise<string> {
}
}
+function webSocketRequest(
+ url: string,
+ options: { poolKey?: string } = {},
+): ReturnType<typeof codexWebSocketRequest> {
+ return codexWebSocketRequest({
+ url,
+ headers: new Headers(),
+ body: body(),
+ ctx: ctx(),
+ connectTimeoutMs: websocketTimeoutMs.connect,
+ idleTimeoutMs: websocketTimeoutMs.idle,
+ ...options,
+ });
+}
+
async function withServer(
handler: (socket: WebSocket, requestBody: Promise<unknown>, request: import("node:http").IncomingMessage) => void,
): Promise<{ url: string; close: () => Promise<void> }> {
@@ -89,6 +109,21 @@ async function withServer(
};
}
+async function withCompletionServer(
+ onConnection: (socket: WebSocket, socketIndex: number) => void,
+): Promise<{ url: string; close: () => Promise<void>; sockets: () => number }> {
+ let sockets = 0;
+ const server = await withServer((socket, requestBody, request) => {
+ const socketIndex = ++sockets;
+ onConnection(socket, socketIndex);
+ });
+ return {
+ url: server.url,
+ close: server.close,
+ sockets: () => sockets,
+ };
+}
+
describe("Codex WebSocket helpers", () => {
it("converts HTTP URLs to WebSocket URLs", () => {
expect(toWebSocketUrl("https://chatgpt.com/backend-api/codex/responses")).toBe(
@@ -139,14 +174,7 @@ describe("Codex WebSocket helpers", () => {
socket.send(JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }));
});
try {
- const stream = await codexWebSocketRequest({
- url: server.url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: 1_000,
- idleTimeoutMs: 1_000,
- });
+ const stream = await webSocketRequest(server.url);
await expect(collect(stream)).resolves.toBe(
'data: {"type":"response.completed","response":{"id":"resp_1"}}\n\n',
@@ -170,14 +198,7 @@ describe("Codex WebSocket helpers", () => {
try {
let caught: unknown;
try {
- await codexWebSocketRequest({
- url: server.url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: 1_000,
- idleTimeoutMs: 1_000,
- });
+ await webSocketRequest(server.url);
} catch (err) {
caught = err;
}
@@ -203,14 +224,7 @@ describe("Codex WebSocket helpers", () => {
);
});
try {
- const stream = await codexWebSocketRequest({
- url: server.url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: 1_000,
- idleTimeoutMs: 1_000,
- });
+ const stream = await webSocketRequest(server.url);
await expect(collect(stream)).resolves.toBe(
'data: {"type":"error","error":{"code":"invalid_request","message":"bad request"}}\n\n',
@@ -221,29 +235,23 @@ describe("Codex WebSocket helpers", () => {
});
it("reuses a pooled websocket", async () => {
- let sockets = 0;
- const server = await withServer((socket) => {
- sockets++;
+ const server = await withCompletionServer((socket, socketIndex) => {
socket.on("message", () => {
- socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${sockets}` } }));
+ socket.send(
+ JSON.stringify({ type: "response.completed", response: { id: `resp_${socketIndex}` } }),
+ );
});
});
try {
const request = () =>
- codexWebSocketRequest({
- url: server.url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: 1_000,
- idleTimeoutMs: 1_000,
+ webSocketRequest(server.url, {
poolKey: "session-1",
});
await collect(await request());
await collect(await request());
- expect(sockets).toBe(1);
+ expect(server.sockets()).toBe(1);
} finally {
clearCodexWebSocketPoolForTests();
await server.close();
@@ -251,27 +259,19 @@ describe("Codex WebSocket helpers", () => {
});
it("does not pool websocket requests without a pool key", async () => {
- let sockets = 0;
- const server = await withServer((socket) => {
- sockets++;
+ const server = await withCompletionServer((socket, socketIndex) => {
socket.on("message", () => {
- socket.send(JSON.stringify({ type: "response.completed", response: { id: `resp_${sockets}` } }));
+ socket.send(
+ JSON.stringify({ type: "response.completed", response: { id: `resp_${socketIndex}` } }),
+ );
});
});
try {
- const makeRequest = () =>
- codexWebSocketRequest({
- url: server.url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: 1_000,
- idleTimeoutMs: 1_000,
- }).then(collect);
+ const makeRequest = () => webSocketRequest(server.url).then(collect);
await makeRequest();
await makeRequest();
- expect(sockets).toBe(2);
+ expect(server.sockets()).toBe(2);
} finally {
await server.close();
}