fix(codex): timeouts for websockets (#4979)

This commit is contained in:
Armin Ronacher
2026-05-27 12:11:29 +02:00
committed by GitHub
parent 26f1e00f71
commit 493efd422d
10 changed files with 551 additions and 48 deletions

View File

@@ -933,6 +933,280 @@ describe("openai-codex streaming", () => {
});
});
it("falls back to SSE when websocket connect does not open before the connect timeout", async () => {
vi.useFakeTimers();
const token = mockToken();
const encoder = new TextEncoder();
const sse = buildSSEPayload({ status: "completed" });
const fetchMock = vi.fn(async (input: string | URL) => {
const url = typeof input === "string" ? input : input.toString();
if (url !== "https://chatgpt.com/backend-api/codex/responses") {
throw new Error(`Unexpected URL: ${url}`);
}
return new Response(
new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode(sse));
controller.close();
},
}),
{ status: 200, headers: { "content-type": "text/event-stream" } },
);
});
vi.stubGlobal("fetch", fetchMock);
class MockWebSocket {
private listeners = new Map<string, Set<(event: unknown) => void>>();
addEventListener(type: string, listener: (event: unknown) => void): void {
let listeners = this.listeners.get(type);
if (!listeners) {
listeners = new Set();
this.listeners.set(type, listeners);
}
listeners.add(listener);
}
removeEventListener(type: string, listener: (event: unknown) => void): void {
this.listeners.get(type)?.delete(listener);
}
send(): void {
throw new Error("send should not be called before websocket open");
}
close(): void {}
}
vi.stubGlobal("WebSocket", MockWebSocket);
const model: Model<"openai-codex-responses"> = {
id: "gpt-5.1-codex",
name: "GPT-5.1 Codex",
api: "openai-codex-responses",
provider: "openai-codex",
baseUrl: "https://chatgpt.com/backend-api",
reasoning: true,
input: ["text"],
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
contextWindow: 400000,
maxTokens: 128000,
};
const context: Context = {
systemPrompt: "You are a helpful assistant.",
messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
};
const resultPromise = streamOpenAICodexResponses(model, context, {
apiKey: token,
sessionId: "ws-connect-timeout",
transport: "auto",
timeoutMs: 300_000,
websocketConnectTimeoutMs: 50,
}).result();
await vi.advanceTimersByTimeAsync(50);
const result = await resultPromise;
expect(result.content.find((content) => content.type === "text")?.text).toBe("Hello");
expect(fetchMock).toHaveBeenCalledTimes(1);
expect(getOpenAICodexWebSocketDebugStats("ws-connect-timeout")).toMatchObject({
websocketFailures: 1,
sseFallbacks: 1,
websocketFallbackActive: true,
lastWebSocketError: "WebSocket connect timeout after 50ms",
});
});
it("falls back to SSE when a websocket is idle before the first event", async () => {
vi.useFakeTimers();
const token = mockToken();
const sentBodies: unknown[] = [];
const encoder = new TextEncoder();
const sse = buildSSEPayload({ status: "completed" });
const fetchMock = vi.fn(async (input: string | URL) => {
const url = typeof input === "string" ? input : input.toString();
if (url !== "https://chatgpt.com/backend-api/codex/responses") {
throw new Error(`Unexpected URL: ${url}`);
}
return new Response(
new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode(sse));
controller.close();
},
}),
{ status: 200, headers: { "content-type": "text/event-stream" } },
);
});
vi.stubGlobal("fetch", fetchMock);
class MockWebSocket {
static OPEN = 1;
readyState = MockWebSocket.OPEN;
private listeners = new Map<string, Set<(event: unknown) => void>>();
constructor(_url: string, _protocols?: string | string[] | { headers?: Record<string, string> }) {
queueMicrotask(() => this.dispatch("open", {}));
}
addEventListener(type: string, listener: (event: unknown) => void): void {
let listeners = this.listeners.get(type);
if (!listeners) {
listeners = new Set();
this.listeners.set(type, listeners);
}
listeners.add(listener);
}
removeEventListener(type: string, listener: (event: unknown) => void): void {
this.listeners.get(type)?.delete(listener);
}
send(data: string): void {
sentBodies.push(JSON.parse(data));
}
close(): void {
this.readyState = 3;
}
private dispatch(type: string, event: unknown): void {
for (const listener of this.listeners.get(type) ?? []) {
listener(event);
}
}
}
vi.stubGlobal("WebSocket", MockWebSocket);
const model: Model<"openai-codex-responses"> = {
id: "gpt-5.1-codex",
name: "GPT-5.1 Codex",
api: "openai-codex-responses",
provider: "openai-codex",
baseUrl: "https://chatgpt.com/backend-api",
reasoning: true,
input: ["text"],
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
contextWindow: 400000,
maxTokens: 128000,
};
const context: Context = {
systemPrompt: "You are a helpful assistant.",
messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
};
const resultPromise = streamOpenAICodexResponses(model, context, {
apiKey: token,
sessionId: "ws-idle-before-start",
transport: "auto",
timeoutMs: 50,
}).result();
await vi.advanceTimersByTimeAsync(0);
expect(sentBodies).toHaveLength(1);
await vi.advanceTimersByTimeAsync(50);
const result = await resultPromise;
expect(result.content.find((content) => content.type === "text")?.text).toBe("Hello");
expect(fetchMock).toHaveBeenCalledTimes(1);
expect(getOpenAICodexWebSocketDebugStats("ws-idle-before-start")).toMatchObject({
websocketFailures: 1,
sseFallbacks: 1,
websocketFallbackActive: true,
});
});
it("errors when a websocket is idle after the stream started", async () => {
vi.useFakeTimers();
const token = mockToken();
const fetchMock = vi.fn(async () => new Response("unexpected fetch", { status: 500 }));
vi.stubGlobal("fetch", fetchMock);
class MockWebSocket {
static OPEN = 1;
readyState = MockWebSocket.OPEN;
private listeners = new Map<string, Set<(event: unknown) => void>>();
constructor(_url: string, _protocols?: string | string[] | { headers?: Record<string, string> }) {
queueMicrotask(() => this.dispatch("open", {}));
}
addEventListener(type: string, listener: (event: unknown) => void): void {
let listeners = this.listeners.get(type);
if (!listeners) {
listeners = new Set();
this.listeners.set(type, listeners);
}
listeners.add(listener);
}
removeEventListener(type: string, listener: (event: unknown) => void): void {
this.listeners.get(type)?.delete(listener);
}
send(): void {
queueMicrotask(() => {
this.dispatch("message", {
data: JSON.stringify({
type: "response.output_item.added",
item: { type: "message", id: "msg_1", role: "assistant", status: "in_progress", content: [] },
}),
});
});
}
close(): void {
this.readyState = 3;
}
private dispatch(type: string, event: unknown): void {
for (const listener of this.listeners.get(type) ?? []) {
listener(event);
}
}
}
vi.stubGlobal("WebSocket", MockWebSocket);
const model: Model<"openai-codex-responses"> = {
id: "gpt-5.1-codex",
name: "GPT-5.1 Codex",
api: "openai-codex-responses",
provider: "openai-codex",
baseUrl: "https://chatgpt.com/backend-api",
reasoning: true,
input: ["text"],
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
contextWindow: 400000,
maxTokens: 128000,
};
const context: Context = {
systemPrompt: "You are a helpful assistant.",
messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
};
const resultPromise = streamOpenAICodexResponses(model, context, {
apiKey: token,
transport: "auto",
timeoutMs: 50,
}).result();
await vi.advanceTimersByTimeAsync(0);
await vi.advanceTimersByTimeAsync(50);
const result = await resultPromise;
expect(result.stopReason).toBe("error");
expect(result.errorMessage).toBe("WebSocket idle timeout after 50ms");
expect(fetchMock).not.toHaveBeenCalled();
});
it("sends only response input deltas in websocket-cached mode", async () => {
const token = mockToken();
const sentBodies: unknown[] = [];