Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

[RSI] fix(ai): reset the codex continuation chain on previous_response_not_found (#2314)

Seth Karten7d1913969d33
diff --git a/packages/ai/.changes/fix-codex-chain-reset.md b/packages/ai/.changes/fix-codex-chain-reset.md
new file mode 100644
index 0000000000..07315980d0
--- /dev/null
+++ b/packages/ai/.changes/fix-codex-chain-reset.md
@@ -0,0 +1 @@
+- Fixed codex websocket sessions repeatedly failing after a stale cached previous_response_id: the continuation chain is now connection-scoped (a reconnected connection always resends the full context), and a previous_response_not_found failure drops the cached chain and retries once with the full request body, re-anchoring on the successful response.
diff --git a/packages/ai/src/providers/openai-codex-responses.ts b/packages/ai/src/providers/openai-codex-responses.ts
index b1eca527d1..a3af062915 100644
--- a/packages/ai/src/providers/openai-codex-responses.ts
+++ b/packages/ai/src/providers/openai-codex-responses.ts
@@ -142,50 +142,64 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
if (transport !== "sse" && !websocketDisabledForSession) {
let websocketStarted = false;
- try {
- await processWebSocketStream(
- resolveCodexWebSocketUrl(model.baseUrl),
- body,
- websocketHeaders,
- output,
- stream,
- model,
- () => {
- websocketStarted = true;
- },
- options,
- );
-
- if (options?.signal?.aborted) {
- throw new Error("Request was aborted");
- }
- stream.push({
- type: "done",
- reason: output.stopReason as "stop" | "length" | "toolUse",
- message: output,
- });
- stream.end();
- return;
- } catch (error) {
- const aborted = options?.signal?.aborted;
- if (aborted || isCodexNonTransportError(error)) {
- throw error;
- }
- appendAssistantMessageDiagnostic(
- output,
- createAssistantMessageDiagnostic("provider_transport_failure", error, {
- configuredTransport: transport,
- fallbackTransport: websocketStarted ? undefined : "sse",
- eventsEmitted: websocketStarted,
- phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
- requestBytes: new TextEncoder().encode(bodyJson).byteLength,
- }),
- );
- recordWebSocketFailure(options?.sessionId, error);
- if (websocketStarted) {
- throw error;
+ // Retry a stale previous_response_id once on a fresh connection: the
+ // failed attempt's error cleanup already dropped the cached connection
+ // entry, so the retry resends the full request body. Any further
+ // failure takes the shared error handling below.
+ let chainResetRetried = false;
+ for (;;) {
+ try {
+ await processWebSocketStream(
+ resolveCodexWebSocketUrl(model.baseUrl),
+ body,
+ websocketHeaders,
+ output,
+ stream,
+ model,
+ () => {
+ websocketStarted = true;
+ },
+ options,
+ );
+
+ if (options?.signal?.aborted) {
+ throw new Error("Request was aborted");
+ }
+ stream.push({
+ type: "done",
+ reason: output.stopReason as "stop" | "length" | "toolUse",
+ message: output,
+ });
+ stream.end();
+ return;
+ } catch (error) {
+ const aborted = options?.signal?.aborted;
+ // Only reset the chain while nothing was streamed yet: after the
+ // first event the retry would duplicate "start"/content events.
+ if (!aborted && !websocketStarted && !chainResetRetried && isStaleCodexContinuationError(error)) {
+ chainResetRetried = true;
+ continue;
+ }
+ if (aborted || isCodexNonTransportError(error)) {
+ throw error;
+ }
+ appendAssistantMessageDiagnostic(
+ output,
+ createAssistantMessageDiagnostic("provider_transport_failure", error, {
+ configuredTransport: transport,
+ fallbackTransport: websocketStarted ? undefined : "sse",
+ eventsEmitted: websocketStarted,
+ phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+ requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+ }),
+ );
+ recordWebSocketFailure(options?.sessionId, error);
+ if (websocketStarted) {
+ throw error;
+ }
+ recordWebSocketSseFallback(options?.sessionId);
+ break;
}
- recordWebSocketSseFallback(options?.sessionId);
}
}
@@ -425,6 +439,16 @@ function isCodexNonTransportError(error: unknown): boolean {
return error instanceof CodexApiError || error instanceof CodexProtocolError;
}
+const STALE_CONTINUATION_ERROR_CODE = "previous_response_not_found";
+
+/**
+ * Codex API error for a previous_response_id the server does not recognize;
+ * the request must be resent in full instead of chained.
+ */
+function isStaleCodexContinuationError(error: unknown): boolean {
+ return error instanceof CodexApiError && error.code?.toLowerCase() === STALE_CONTINUATION_ERROR_CODE;
+}
+
async function* mapCodexEvents(events: AsyncIterable<Record<string, unknown>>): AsyncGenerator<ResponseStreamEvent> {
for await (const event of events) {
const type = typeof event.type === "string" ? event.type : undefined;
@@ -545,6 +569,8 @@ interface CachedWebSocketContinuationState {
lastRequestBody: RequestBody;
lastResponseId: string;
lastResponseItems: ResponseInput;
+ /** Connection whose server-side response state this chain is anchored to. */
+ connection: WebSocketLike;
}
interface CachedWebSocketConnection {
@@ -1051,6 +1077,13 @@ function buildCachedWebSocketRequestBody(entry: CachedWebSocketConnection, body:
return body;
}
+ // Continuations are anchored to the connection that produced the response;
+ // a different socket cannot resolve their previous_response_id.
+ if (continuation.connection !== entry.socket) {
+ entry.continuation = undefined;
+ return body;
+ }
+
const delta = getCachedWebSocketInputDelta(body, continuation);
if (!delta || !continuation.lastResponseId) {
entry.continuation = undefined;
@@ -1144,6 +1177,7 @@ async function processWebSocketStream(
lastRequestBody: fullBody,
lastResponseId: output.responseId,
lastResponseItems: responseItems,
+ connection: entry.socket,
};
}
} catch (error) {
diff --git a/packages/ai/test/openai-codex-stream.test.ts b/packages/ai/test/openai-codex-stream.test.ts
index cd7f6ab979..2f1645357a 100644
--- a/packages/ai/test/openai-codex-stream.test.ts
+++ b/packages/ai/test/openai-codex-stream.test.ts
@@ -1008,6 +1008,247 @@ describe("openai-codex streaming", () => {
});
});
+ it("sends full context without a stale previous_response_id after a reconnect and re-anchors", async () => {
+ const token = mockToken();
+ let firstSocket: ScriptedWebSocketHandle | undefined;
+ const sentBodies = installScriptedCodexWebSocket([
+ (socket) => {
+ firstSocket = socket;
+ socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" }));
+ },
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_2", messageId: "msg_2", text: "Done" })),
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_3", messageId: "msg_3", text: "Again" })),
+ ]);
+
+ const model = codexTestModel();
+ const firstContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
+ };
+ const first = await streamOpenAICodexResponses(model, firstContext, {
+ apiKey: token,
+ sessionId: "session-reconnect",
+ transport: "websocket-cached",
+ }).result();
+
+ // The server dropped the connection during the idle gap between turns.
+ firstSocket?.drop();
+
+ const secondContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
+ };
+ const second = await streamOpenAICodexResponses(model, secondContext, {
+ apiKey: token,
+ sessionId: "session-reconnect",
+ transport: "websocket-cached",
+ }).result();
+
+ expect(second.stopReason).toBe("stop");
+
+ const thirdContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...secondContext.messages, second, { role: "user", content: "And again", timestamp: 3 }],
+ };
+ await streamOpenAICodexResponses(model, thirdContext, {
+ apiKey: token,
+ sessionId: "session-reconnect",
+ transport: "websocket-cached",
+ }).result();
+
+ expect(sentBodies).toHaveLength(3);
+ const reconnectedBody = sentBodies[1] as { previous_response_id?: string; input: unknown[] };
+ const resumedBody = sentBodies[2] as { previous_response_id?: string; input: unknown[] };
+ // The reconnected connection starts from the full context, never the dead
+ // connection's previous_response_id.
+ expect(reconnectedBody.previous_response_id).toBeUndefined();
+ expect(reconnectedBody.input).toEqual([
+ { role: "user", content: [{ type: "input_text", text: "Say hello" }] },
+ {
+ type: "message",
+ role: "assistant",
+ content: [{ type: "output_text", text: "Hello", annotations: [] }],
+ status: "completed",
+ id: "msg_1",
+ },
+ { role: "user", content: [{ type: "input_text", text: "Now finish" }] },
+ ]);
+ // The chain re-anchors on the reconnected connection's response.
+ expect(resumedBody.previous_response_id).toBe("resp_2");
+ expect(resumedBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "And again" }] }]);
+ expect(global.fetch).not.toHaveBeenCalled();
+ expect(getOpenAICodexWebSocketDebugStats("session-reconnect")).toMatchObject({
+ requests: 3,
+ connectionsCreated: 2,
+ connectionsReused: 1,
+ fullContextRequests: 2,
+ deltaRequests: 1,
+ lastPreviousResponseId: "resp_2",
+ });
+ });
+
+ it("recovers a stale previous_response_id with one full-context chain-reset retry", async () => {
+ const token = mockToken();
+ const sentBodies = installScriptedCodexWebSocket([
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
+ (socket) =>
+ socket.emit(
+ codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_1' not found"),
+ ),
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_2", messageId: "msg_2", text: "Done" })),
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_3", messageId: "msg_3", text: "Again" })),
+ ]);
+
+ const model = codexTestModel();
+ const firstContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
+ };
+
+ const first = await streamOpenAICodexResponses(model, firstContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset",
+ transport: "websocket-cached",
+ }).result();
+
+ const secondContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
+ };
+ const second = await streamOpenAICodexResponses(model, secondContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset",
+ transport: "websocket-cached",
+ }).result();
+
+ // The stale continuation was recovered within the same turn.
+ expect(second.stopReason).toBe("stop");
+ expect(second.content[0]).toMatchObject({ type: "text", text: "Done" });
+
+ // A later turn proves the chain resumed from the retried response.
+ const thirdContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...secondContext.messages, second, { role: "user", content: "And again", timestamp: 3 }],
+ };
+ await streamOpenAICodexResponses(model, thirdContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset",
+ transport: "websocket-cached",
+ }).result();
+
+ expect(sentBodies).toHaveLength(4);
+ const deltaBody = sentBodies[1] as { previous_response_id?: string; input: unknown[] };
+ const retryBody = sentBodies[2] as { previous_response_id?: string; input: unknown[] };
+ const resumedBody = sentBodies[3] as { previous_response_id?: string; input: unknown[] };
+ expect(deltaBody.previous_response_id).toBe("resp_1");
+ expect(deltaBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "Now finish" }] }]);
+ // The chain reset resends the full request body without previous_response_id.
+ expect(retryBody.previous_response_id).toBeUndefined();
+ expect(retryBody.input).toEqual([
+ { role: "user", content: [{ type: "input_text", text: "Say hello" }] },
+ {
+ type: "message",
+ role: "assistant",
+ content: [{ type: "output_text", text: "Hello", annotations: [] }],
+ status: "completed",
+ id: "msg_1",
+ },
+ { role: "user", content: [{ type: "input_text", text: "Now finish" }] },
+ ]);
+ expect(resumedBody.previous_response_id).toBe("resp_2");
+ expect(resumedBody.input).toEqual([{ role: "user", content: [{ type: "input_text", text: "And again" }] }]);
+ expect(global.fetch).not.toHaveBeenCalled();
+ expect(getOpenAICodexWebSocketDebugStats("session-chain-reset")).toMatchObject({
+ requests: 4,
+ connectionsCreated: 2,
+ connectionsReused: 2,
+ cachedContextRequests: 4,
+ fullContextRequests: 2,
+ deltaRequests: 2,
+ websocketFailures: 0,
+ sseFallbacks: 0,
+ });
+ });
+
+ it("surfaces the error without further retries when the chain-reset retry fails again", async () => {
+ const token = mockToken();
+ const sentBodies = installScriptedCodexWebSocket([
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
+ (socket) =>
+ socket.emit(
+ codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_1' not found"),
+ ),
+ (socket) =>
+ socket.emit(
+ codexErrorEvents("previous_response_not_found", "Previous response with id 'resp_9' not found"),
+ ),
+ ]);
+
+ const model = codexTestModel();
+ const firstContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
+ };
+ const first = await streamOpenAICodexResponses(model, firstContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset-fail",
+ transport: "websocket-cached",
+ }).result();
+
+ const secondContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
+ };
+ const second = await streamOpenAICodexResponses(model, secondContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset-fail",
+ transport: "websocket-cached",
+ }).result();
+
+ expect(second.stopReason).toBe("error");
+ expect(second.errorMessage).toBe("Codex error: Previous response with id 'resp_9' not found");
+ // Exactly one chain-reset retry, then the error surfaces unchanged.
+ expect(sentBodies).toHaveLength(3);
+ const retryBody = sentBodies[2] as { previous_response_id?: string };
+ expect(retryBody.previous_response_id).toBeUndefined();
+ expect(global.fetch).not.toHaveBeenCalled();
+ expect(failureDetails(second)).toMatchObject({ providerErrorType: "previous_response_not_found" });
+ });
+
+ it("does not chain-reset retry other codex api errors", async () => {
+ const token = mockToken();
+ const sentBodies = installScriptedCodexWebSocket([
+ (socket) => socket.emit(codexResponseEvents({ responseId: "resp_1", messageId: "msg_1", text: "Hello" })),
+ (socket) => socket.emit(codexErrorEvents("invalid_request", "Invalid request")),
+ ]);
+
+ const model = codexTestModel();
+ const firstContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [{ role: "user", content: "Say hello", timestamp: 1 }],
+ };
+ const first = await streamOpenAICodexResponses(model, firstContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset-other",
+ transport: "websocket-cached",
+ }).result();
+
+ const secondContext: Context = {
+ systemPrompt: "You are a helpful assistant.",
+ messages: [...firstContext.messages, first, { role: "user", content: "Now finish", timestamp: 2 }],
+ };
+ const second = await streamOpenAICodexResponses(model, secondContext, {
+ apiKey: token,
+ sessionId: "session-chain-reset-other",
+ transport: "websocket-cached",
+ }).result();
+
+ expect(second.stopReason).toBe("error");
+ expect(second.errorMessage).toBe("Codex error: Invalid request");
+ expect(sentBodies).toHaveLength(2);
+ expect(global.fetch).not.toHaveBeenCalled();
+ });
+
function codexTestModel(): Model<"openai-codex-responses"> {
return {
id: "gpt-5.1-codex",
@@ -1059,6 +1300,128 @@ describe("openai-codex streaming", () => {
: undefined;
}
+ /** Handle the send scripts use to drive a mocked websocket connection. */
+ interface ScriptedWebSocketHandle {
+ emit: (events: unknown[]) => void;
+ /** Simulate the server dropping the connection between turns. */
+ drop: () => void;
+ }
+
+ /**
+ * Install a scripted WebSocket mock: every websocket send consumes one
+ * script entry (across socket instances, so reconnects stay scripted) and
+ * fetch is stubbed so an unexpected SSE fallback fails fast.
+ */
+ function installScriptedCodexWebSocket(
+ scripts: Array<(socket: ScriptedWebSocketHandle) => void>,
+ ): Record<string, unknown>[] {
+ const sentBodies: Record<string, unknown>[] = [];
+
+ 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) as Record<string, unknown>);
+ const script = scripts.shift();
+ if (!script) throw new Error("unexpected websocket request");
+ queueMicrotask(() =>
+ script({
+ emit: (events: unknown[]) => this.emit(events),
+ drop: () => {
+ this.readyState = 3;
+ },
+ }),
+ );
+ }
+
+ close(): void {
+ this.readyState = 3;
+ }
+
+ emit(events: unknown[]): void {
+ for (const event of events) {
+ this.dispatch("message", { data: JSON.stringify(event) });
+ }
+ }
+
+ private dispatch(type: string, event: unknown): void {
+ for (const listener of this.listeners.get(type) ?? []) {
+ listener(event);
+ }
+ }
+ }
+
+ global.fetch = vi.fn(async () => new Response("unexpected fetch", { status: 500 })) as typeof fetch;
+ globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;
+ return sentBodies;
+ }
+
+ function codexResponseEvents({
+ responseId,
+ messageId,
+ text,
+ }: {
+ responseId: string;
+ messageId: string;
+ text: string;
+ }): unknown[] {
+ return [
+ { type: "response.created", response: { id: responseId } },
+ {
+ type: "response.output_item.added",
+ item: { type: "message", id: messageId, role: "assistant", status: "in_progress", content: [] },
+ },
+ { type: "response.content_part.added", part: { type: "output_text", text: "" } },
+ { type: "response.output_text.delta", delta: text },
+ {
+ type: "response.output_item.done",
+ item: {
+ type: "message",
+ id: messageId,
+ role: "assistant",
+ status: "completed",
+ content: [{ type: "output_text", text }],
+ },
+ },
+ {
+ type: "response.completed",
+ response: {
+ id: responseId,
+ status: "completed",
+ usage: {
+ input_tokens: 5,
+ output_tokens: 3,
+ total_tokens: 8,
+ input_tokens_details: { cached_tokens: 0 },
+ },
+ },
+ },
+ ];
+ }
+
+ function codexErrorEvents(code: string, message: string): unknown[] {
+ return [{ type: "error", code, message }];
+ }
+
it("throws a structured failure after a single attempt on HTTP 500", async () => {
const counter = stubCodexFetch(
() => new Response(JSON.stringify({ error: { type: "server_error", message: "boom" } }), { status: 500 }),