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.mdnew file mode 100644index 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.tsindex 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.tsindex 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 }),