@qduc/term2 0.13.0 → 0.15.0

package/dist/providers/codex-responses-model.js

@@ -1,14 +1,20 @@
 import { randomUUID } from 'node:crypto';
 import { ResponsesWS } from 'openai/resources/responses/ws';
-import OpenAI from 'openai';
+import OpenAI, { InternalServerError } from 'openai';
 import { toCodexResponsesInput } from './codex-turn-converter.js';
 import { sanitizeHeaders } from '../utils/header-sanitizer.js';
-import { OrphanedChainedToolOutputError } from '../lib/chained-input-filter.js';
-import { AmbiguousModelOutcomeError } from '../services/retry/retry-errors.js';
+import { AbortedStreamRecorder } from './aborted-stream-recorder.js';
+import { isOrphanedChainedToolOutputError, OrphanedChainedToolOutputError } from '../lib/chained-input-filter.js';
+import { AmbiguousModelOutcomeError, ConversationStateNoProgressError } from '../services/retry/retry-errors.js';
+import { fingerprintChainRequest } from '../services/retry/chain-recovery-fingerprint.js';
 import { ChainedWireState } from './chained-wire-state.js';
 import { LunaResponsesLiteWireProtocol } from './luna-responses-lite-wire-protocol.js';
 import { captureProviderRequest } from './provider-request-capture.js';
 import { createWebSocketReceiveWatchdog, DEFAULT_WEBSOCKET_RECEIVE_TIMEOUTS, } from './websocket-receive-watchdog.js';
+import { readWebSocketDispatch, recordWebSocketDispatch, UnsentWebSocketRequestError, } from './websocket-request-dispatch.js';
+import { WebSocketClosedEarlyError, webSocketCloseError, findWebSocketClosedEarly, readWebSocketCloseFrame, } from './websocket-close-evidence.js';
+import { markContextCompactionFailure, resolveContextManagement } from './openai-responses-model.js';
+import { ResponsesWebSocketSessions } from './responses-websocket-sessions.js';
 const DUMMY_PROVIDER_TRAFFIC = {
     recordRequestStart() { },
     async recordResponseReceived() { },
@@ -23,19 +29,38 @@ function toCodexToolChoice(choice) {
     }
     throw new Error('Unsupported Codex tool choice.');
 }
+const TERMINAL_RESPONSE_EVENT_TYPES = new Set([
+    'response.completed',
+    'response.failed',
+    'response.incomplete',
+    'response.error',
+]);
+// RFC 6455 readyState values, named so the send path's evidence is readable.
+const WEBSOCKET_CONNECTING = 0;
+const WEBSOCKET_OPEN = 1;
 /** Provider-owned transport seam used by Codex's HTTP and WebSocket models. */
 export class CodexResponsesTransport {
     client;
     model;
     websocket;
-    constructor(client = {}, model = '', websocket = false) {
+    options;
+    #sessions = new ResponsesWebSocketSessions((headers) => new ResponsesWS(this.client, headers ? { headers } : undefined));
+    constructor(client = {}, model = '', websocket = false, options = {}) {
         this.client = client;
         this.model = model;
         this.websocket = websocket;
+        this.options = options;
+    }
+    close() {
+        this.#sessions.close();
     }
     buildResponsesCreateRequest(request, stream) {
         const providerOptions = request.providerOptions ?? {};
-        const { extraBody, extraHeaders: _extraHeaders, ...nativeProviderData } = providerOptions;
+        // contextCompaction is an app-level option; context_management is capability-gated
+        // below. Do not let either leak through native provider data or extraBody.
+        const { extraBody, extraHeaders: _extraHeaders, contextCompaction: _contextCompaction, ...nativeProviderData } = providerOptions;
+        const { context_management: _reservedContextManagement, ...safeExtraBody } = (extraBody ?? {});
+        const contextManagement = resolveContextManagement(providerOptions, this.model, this.options.supportsContextCompaction === true, this.options.contextCompactionSessionState);
         return {
             requestData: {
                 model: this.model,
@@ -51,55 +76,96 @@ export class CodexResponsesTransport {
                 ...(request.maxTokens !== undefined ? { max_output_tokens: request.maxTokens } : {}),
                 ...(request.reasoning !== undefined ? { reasoning: request.reasoning } : {}),
                 ...nativeProviderData,
-                ...(extraBody ?? {}),
+                ...safeExtraBody,
                 ...(request.previousResponseId ? { previous_response_id: request.previousResponseId } : {}),
                 ...(request.codex?.promptCacheKey ? { prompt_cache_key: request.codex.promptCacheKey } : {}),
                 ...(request.codex?.include ? { include: request.codex.include } : {}),
+                ...(contextManagement ? { context_management: contextManagement } : {}),
             },
         };
     }
     async fetchResponse(request, stream, requestData) {
-        if (stream && this.websocket) {
-            if (!(this.client instanceof OpenAI) && typeof this.client?.responses?.create === 'function') {
-                return this.client.responses.create(requestData);
-            }
-            const headers = request.providerOptions?.extraHeaders;
-            const socket = new ResponsesWS(this.client, headers ? { headers: headers } : undefined);
-            const messages = socket.stream();
-            const requestEvent = { type: 'response.create', ...requestData };
-            if (socket.socket?.readyState === 0) {
-                socket.socket.once('open', () => socket.send(requestEvent));
-            }
-            else {
-                socket.send(requestEvent);
-            }
-            return (async function* () {
-                try {
-                    for await (const message of messages) {
-                        if (message.type === 'message')
-                            yield message.message;
-                        else if (message.event)
-                            yield message.event;
-                        else if (message.type === 'error')
-                            throw message.error;
-                        else if (message.type === 'close')
-                            throw new Error('Codex WebSocket connection closed before a terminal response event.');
-                    }
+        try {
+            if (stream && this.websocket) {
+                if (!(this.client instanceof OpenAI) && typeof this.client?.responses?.create === 'function') {
+                    return this.client.responses.create(requestData);
                 }
-                finally {
+                const headers = request.providerOptions?.extraHeaders;
+                const socket = this.#sessions.acquire(headers);
+                const messages = socket.stream();
+                const requestEvent = { type: 'response.create', ...requestData };
+                // Until the frame is written to an OPEN socket it is still ours, so a
+                // receive timeout before that point is provably unsent. `send` on a
+                // connecting or closing socket only queues, which proves nothing —
+                // record what the socket actually was, and `unknown` when it cannot be
+                // observed at all.
+                recordWebSocketDispatch(request, 'unsent');
+                const dispatchRequestEvent = () => {
+                    const readyState = socket.socket?.readyState;
+                    socket.send(requestEvent);
+                    recordWebSocketDispatch(request, readyState === WEBSOCKET_OPEN ? 'flushed' : 'unknown');
+                };
+                if (socket.socket?.readyState === WEBSOCKET_CONNECTING) {
+                    socket.socket.once('open', dispatchRequestEvent);
+                }
+                else {
+                    dispatchRequestEvent();
+                }
+                const sessionState = this.options.contextCompactionSessionState;
+                const sessions = this.#sessions;
+                return (async function* () {
+                    let terminalReceived = false;
+                    let released = false;
+                    const release = (keepAlive) => {
+                        if (released)
+                            return;
+                        released = true;
+                        sessions.release(socket, { keepAlive });
+                    };
                     try {
-                        socket.close();
+                        for await (const message of messages) {
+                            if (message.type === 'message') {
+                                const event = message.message;
+                                if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type) || event?.type === 'response.completed') {
+                                    terminalReceived = true;
+                                }
+                                yield event;
+                            }
+                            else if (message.event) {
+                                const event = message.event;
+                                if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type) || event?.type === 'response.completed') {
+                                    terminalReceived = true;
+                                }
+                                yield event;
+                            }
+                            else if (message.type === 'error') {
+                                throw message.error;
+                            }
+                            else if (message.type === 'close') {
+                                throw webSocketCloseError(message, readWebSocketDispatch(request));
+                            }
+                        }
                     }
-                    catch {
-                        /* best effort */
+                    catch (error) {
+                        release(false);
+                        const normalizedError = normalizeExplicitCodexServerError(error);
+                        markContextCompactionFailure(normalizedError, request, sessionState);
+                        throw normalizedError;
                     }
-                }
-            })();
+                    finally {
+                        release(terminalReceived);
+                    }
+                })();
+            }
+            return await this.client.responses.create(requestData, {
+                ...(request.signal ? { signal: request.signal } : {}),
+                ...(request.providerOptions?.extraHeaders ? { headers: request.providerOptions.extraHeaders } : {}),
+            });
+        }
+        catch (error) {
+            markContextCompactionFailure(error, request, this.options.contextCompactionSessionState);
+            throw error;
         }
-        return this.client.responses.create(requestData, {
-            ...(request.signal ? { signal: request.signal } : {}),
-            ...(request.providerOptions?.extraHeaders ? { headers: request.providerOptions.extraHeaders } : {}),
-        });
     }
 }
 export class OpenAIResponsesModel {
@@ -111,6 +177,9 @@ export class OpenAIResponsesModel {
         this.model = model;
         this.transport = transport ?? new CodexResponsesTransport(client, model, websocket);
     }
+    async close() {
+        this.transport.close?.();
+    }
     buildResponsesCreateRequest(request, stream) {
         const built = this.transport.buildResponsesCreateRequest(request, stream);
         if (this.transport instanceof CodexResponsesTransport && built?.requestData) {
@@ -127,16 +196,47 @@ export class OpenAIResponsesModel {
     }
     async *rawStream(request) {
         const source = await this.fetchResponse(request, true);
-        for await (const event of source) {
-            if (event?.type === 'error')
-                throw new Error(event.error?.message ?? 'Codex WebSocket provider error');
-            if (event?.type === 'close')
-                throw new Error('Codex WebSocket connection closed before a terminal response event.');
-            yield event;
-            if (event?.type === 'response.completed' ||
-                event?.type === 'response.incomplete' ||
-                event?.type === 'response.failed')
-                return;
+        const iterator = source[Symbol.asyncIterator]();
+        let terminal = false;
+        let iteratorFinished = false;
+        try {
+            while (true) {
+                const next = await iterator.next();
+                if (next.done) {
+                    iteratorFinished = true;
+                    return;
+                }
+                const event = next.value;
+                if (event?.type === 'error')
+                    throw new Error(event.error?.message ?? 'Codex WebSocket provider error');
+                if (event?.type === 'close')
+                    throw new WebSocketClosedEarlyError(readWebSocketCloseFrame(event));
+                terminal =
+                    event?.type === 'response.completed' ||
+                        event?.type === 'response.incomplete' ||
+                        event?.type === 'response.failed';
+                yield event;
+                if (terminal)
+                    return;
+            }
+        }
+        finally {
+            if (!iteratorFinished) {
+                if (terminal) {
+                    // The Responses WebSocket stream is session-scoped. Detach this
+                    // completed request without awaiting an SDK iterator return that
+                    // waits for the retained socket to close.
+                    try {
+                        void iterator.return?.().catch(() => undefined);
+                    }
+                    catch {
+                        // Completion is authoritative; socket disposal remains best effort.
+                    }
+                }
+                else {
+                    await iterator.return?.();
+                }
+            }
         }
     }
     async *stream(request) {
@@ -318,19 +418,29 @@ function toCodexUsage(rawUsage) {
 function codexString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-import { isIncompleteStreamTerminalError, isPreviousResponseNotFoundError, isRetryableTransportError, isWebSocketConnectionLimitReachedError, } from '../services/retry/retry-error-classification.js';
+import { isIncompleteStreamTerminalError, isMissingServerToolOutputError, isPreviousResponseNotFoundError, isRetryableTransportError, isWebSocketConnectionLimitReachedError, } from '../services/retry/retry-error-classification.js';
 const SUSPICIOUS_RECONSTRUCTED_OUTPUT_ITEM_COUNT = 20;
-const TERMINAL_RESPONSE_EVENT_TYPES = new Set([
-    'response.completed',
-    'response.failed',
-    'response.incomplete',
-    'response.error',
-]);
 const WS_RESPONSE_MODEL_CLASS = 'OpenAIResponsesWSModel';
 const WS_RESPONSE_WRAPPER_CLASS = 'CodexResponsesWSModel';
 const RESPONSES_LITE_MODELS = new Set(['gpt-5.6-luna']);
 const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 const stringValue = (value) => (typeof value === 'string' && value ? value : undefined);
+/**
+ * A Codex WebSocket `error` frame is an explicit provider rejection, unlike a
+ * socket close after sending a request. Normalize only its documented
+ * `server_error` shape to the SDK's 5xx error so the pre-event retry wrapper
+ * can retry it without treating an ambiguous outcome as safe to replay.
+ */
+function normalizeExplicitCodexServerError(error) {
+    const outer = asRecord(asRecord(error)?.error) ?? asRecord(error);
+    const details = asRecord(outer?.error) ?? outer;
+    if (!details || (details.type !== 'server_error' && details.code !== 'server_error')) {
+        return error;
+    }
+    const normalized = new InternalServerError(500, details, stringValue(details.message), new Headers());
+    Object.defineProperty(normalized, 'cause', { value: error, configurable: true });
+    return normalized;
+}
 const CODEX_REPLAY_ITEM_TYPES_WITHOUT_IDS = new Set([
     'message',
     'reasoning',
@@ -577,6 +687,15 @@ const collectFunctionCallIds = (input) => {
     }
     return ids;
 };
+const isExactInputPrefix = (input, prefix) => {
+    if (prefix.length > input.length)
+        return false;
+    return prefix.every((item, index) => JSON.stringify(item) === JSON.stringify(input[index]));
+};
+const collectUnpairedToolResultCallIds = (original, filtered) => {
+    const remaining = new Set(collectToolResultCallIds(filtered));
+    return collectToolResultCallIds(original).filter((callId) => !remaining.has(callId));
+};
 const dropUnpairedCodexToolItems = (history) => {
     const callIds = new Set();
     const resultIds = new Set();
@@ -702,10 +821,26 @@ const isDefinitelyUnsentWebSocketError = (error, seen = new Set()) => {
     }
     return isDefinitelyUnsentWebSocketError(record.message, seen) || isDefinitelyUnsentWebSocketError(record.cause, seen);
 };
+/**
+ * A receive-watchdog timeout that the send path proved never reached the wire.
+ *
+ * Three conditions must all hold, and each rules out a way of being wrong: the
+ * failure is the watchdog's own (not a provider error wearing a timeout
+ * message), no frame ever arrived (a single frame means the server had the
+ * request), and the send path positively recorded `unsent` (an unrecorded
+ * request is not evidence). Anything less stays ambiguous and terminates.
+ */
+const asProvablyUnsentTimeout = (timeoutError, timing, request) => {
+    if (!timeoutError || timing.frameCount > 0)
+        return undefined;
+    if (readWebSocketDispatch(request) !== 'unsent')
+        return undefined;
+    return new UnsentWebSocketRequestError(timeoutError.message, { cause: timeoutError });
+};
 const asAmbiguousModelOutcome = (error) => {
     // Connection never carried the request: safe to let outer retry / transport
     // fallback policies decide. Do not pretend the model may have run.
-    if (isDefinitelyUnsentWebSocketError(error)) {
+    if (error instanceof UnsentWebSocketRequestError || isDefinitelyUnsentWebSocketError(error)) {
         return undefined;
     }
     // Incomplete stream terminals keep transportFallback=false so Codex does not
@@ -720,13 +855,6 @@ const asAmbiguousModelOutcome = (error) => {
     return undefined;
 };
 const hasGenerateFalse = (request) => request.providerOptions?.generate === false;
-const withProviderOptions = (request, providerOptions) => ({
-    ...request,
-    providerOptions: {
-        ...request.providerOptions,
-        ...providerOptions,
-    },
-});
 export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
     modelId;
     tokenManager;
@@ -735,6 +863,9 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
     codexFunctionCallIdsByResponseId = new Map();
     codexTurnIdsBySession = new Map();
     #serverHistoryReuseDisabled = false;
+    #lastSentChainFingerprint;
+    #lastRejectedChainFingerprint;
+    #lastLogicalRequestByKey = new Map();
     providerTraffic;
     diagnosticLogger;
     sessionContextService;
@@ -785,7 +916,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficReceived(requestId, requestData, response) {
+    #logTrafficReceived(requestId, requestData, response, receiveTiming) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordResponseReceived({
@@ -795,11 +926,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             status: 200,
             response: response,
             transport: 'websocket',
+            ...(receiveTiming ? { receiveTiming } : {}),
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficFailed(requestId, requestData, error) {
+    #logTrafficFailed(requestId, requestData, error, receiveTiming) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordRequestFailed({
@@ -807,11 +939,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             provider: 'codex',
             model,
             error,
+            ...(receiveTiming ? { receiveTiming } : {}),
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficClosed(requestId, requestData, outcome, eventCount) {
+    #logTrafficClosed(requestId, requestData, outcome, eventCount, diagnostics) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordResponseClosed({
@@ -820,11 +953,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             model,
             outcome,
             eventCount,
+            ...(diagnostics ? { diagnostics } : {}),
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken, signal) {
+    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken, signal, receiveTiming, asProvablyUnsent) {
         const logReceived = this.#logTrafficReceived.bind(this);
         const logFailed = this.#logTrafficFailed.bind(this);
         const logClosed = this.#logTrafficClosed.bind(this);
@@ -834,9 +968,13 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             let sourceExhausted = false;
             let streamFailed = false;
             let eventCount = 0;
+            // A stream cut off mid-flight produces no payload to summarize later, so
+            // the transcript is retained until a terminal event proves it redundant.
+            const recorder = new AbortedStreamRecorder();
             try {
                 for await (const event of responseStream) {
                     eventCount += 1;
+                    recorder.observe(event);
                     if (event &&
                         typeof event === 'object' &&
                         (event.type === 'response.completed' ||
@@ -848,11 +986,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         typeof event === 'object' &&
                         (event.type === 'response.completed' || event.type === 'response.incomplete') &&
                         event.response) {
+                        recorder.release();
                         const response = event.response;
                         if (wireStateKey && wireStateToken && typeof response.id === 'string' && response.id.length > 0) {
                             wireState.recordResponse(wireStateKey, wireStateToken, response.id, response.output);
                         }
-                        logReceived(requestId, requestData, response);
+                        logReceived(requestId, requestData, response, receiveTiming?.());
                     }
                     yield event;
                 }
@@ -863,13 +1002,22 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 if (wireStateKey && !isWebSocketConnectionLimitReachedError(error)) {
                     wireState.invalidate(wireStateKey);
                 }
-                logFailed(requestId, requestData, error);
-                throw error;
+                // The watchdog's own timeout may carry proof that the request never
+                // reached the wire; the wire-state decision above still keys off the
+                // error as thrown.
+                const failure = asProvablyUnsent?.() ?? error;
+                logFailed(requestId, requestData, failure, receiveTiming?.());
+                throw failure;
             }
             finally {
                 if (!sawTerminalEvent && !sourceExhausted && !streamFailed) {
-                    logClosed(requestId, requestData, signal?.aborted ? 'aborted' : 'consumer_closed', eventCount);
+                    // A consumer-closed stream ended because we stopped reading, which is
+                    // ordinary; its partial output stays out of the log. An abort is the
+                    // failure we cannot otherwise explain, so it keeps the transcript.
+                    const outcome = signal?.aborted ? 'aborted' : 'consumer_closed';
+                    logClosed(requestId, requestData, outcome, eventCount, outcome === 'aborted' ? recorder.diagnostics() : undefined);
                 }
+                recorder.release();
                 if (wireStateKey && wireStateToken) {
                     wireState.abandon(wireStateKey, wireStateToken);
                 }
@@ -877,29 +1025,6 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         }
         return wrapped();
     }
-    async #warmupCodexUnary(request) {
-        if (!request) {
-            return undefined;
-        }
-        const response = await super.fetchUnaryResponse(request);
-        const responseId = getResponseIdFromResponse(response);
-        this.#rememberCodexResponseId(responseId, asRecord(response)?.output, request.input, true);
-        return responseId;
-    }
-    async #warmupCodexStream(request) {
-        if (!request) {
-            return undefined;
-        }
-        let responseId;
-        for await (const event of super.rawStream(request)) {
-            const eventResponseId = getResponseIdFromStreamEvent(event);
-            if (eventResponseId) {
-                responseId = eventResponseId;
-                this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), request.input, true);
-            }
-        }
-        return responseId;
-    }
     #prepareCodexServerHistoryRequest(request) {
         const explicitPreviousResponseId = typeof request.previousResponseId === 'string' && request.previousResponseId.length > 0
             ? request.previousResponseId
@@ -929,28 +1054,33 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         };
     }
     #getRememberedCodexResponseIdForRequest(request) {
-        if (this.#serverHistoryReuseDisabled) {
+        if (this.#serverHistoryReuseDisabled || hasGenerateFalse(request)) {
             return undefined;
         }
         const key = this.#getCodexServerHistoryKey();
-        if (!key || hasGenerateFalse(request)) {
+        const stored = key ? this.#lastLogicalRequestByKey.get(key) : undefined;
+        if (!stored || !Array.isArray(request.input)) {
             return undefined;
         }
-        const hasToolResultBeforeTrailingUserMessages = (items) => {
-            let endUserIndex = items.length;
-            while (endUserIndex > 0 && isUserInputMessage(items[endUserIndex - 1])) {
-                endUserIndex--;
-            }
-            return endUserIndex > 0 && isToolResultItem(items[endUserIndex - 1]);
-        };
-        const input = request.input;
-        const isInternalToolContinuation = Array.isArray(input) &&
-            input.length > 1 &&
-            input.some(isUserInputMessage) &&
-            hasToolResultBeforeTrailingUserMessages(input);
-        return isInternalToolContinuation ? this.codexPreviousResponseIds.get(key) : undefined;
+        return isExactInputPrefix(request.input, stored.input) ? stored.responseId : undefined;
     }
     #prepareCodexServerHistoryRequests(request) {
+        if (request?.disableChaining === true) {
+            this.#forgetCodexResponseId();
+            const { previousResponseId: _previousResponseId, ...rest } = request;
+            const input = Array.isArray(rest.input) ? dropUnpairedCodexToolItems(rest.input) : rest.input;
+            this.diagnosticLogger?.debug?.('Codex chain recovery bypassed warmup and previous_response_id', {
+                eventType: 'codex.chain_recovery.warmup_bypassed',
+                category: 'provider',
+                phase: 'request_prepare',
+                droppedOrphanCallIds: collectUnpairedToolResultCallIds(rest.input, input),
+            });
+            return { request: input === rest.input ? rest : { ...rest, input } };
+        }
+        if (RESPONSES_LITE_MODELS.has(this.modelId)) {
+            const input = Array.isArray(request.input) ? dropUnpairedCodexToolItems(request.input) : request.input;
+            return { request: input === request.input ? request : { ...request, input } };
+        }
         const key = this.#getCodexServerHistoryKey();
         if (!key || hasGenerateFalse(request)) {
             return { request };
@@ -959,52 +1089,31 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (preparedRequest.previousResponseId) {
             return { request: preparedRequest };
         }
+        // No usable server-held anchor, so this request carries its full history.
+        //
+        // Codex's `generate:false` warmup is deliberately not used here. It is only
+        // a win when it can be issued ahead of an upcoming turn, and this call site
+        // sits immediately before the request it would prepare -- so it bought a
+        // serial round trip while the paired generate call still reported the full
+        // uncached prompt (`cached_tokens: 0`), counting the prompt twice. The
+        // response ID that anchors the next turn comes from the generate response
+        // either way, so dropping warmup costs no chaining.
         const input = Array.isArray(request.input) ? dropUnpairedCodexToolItems(request.input) : request.input;
-        const replayRequest = input === request.input ? request : { ...request, input };
-        if (!Array.isArray(input) || input.length === 0) {
-            return { request: replayRequest };
-        }
-        const deltaStart = findServerManagedDeltaStart(input);
-        const warmupItems = deltaStart > 0 ? [...input.slice(0, deltaStart)] : [];
-        const rawDelta = deltaStart > 0 ? input.slice(deltaStart) : [...input];
-        // The trailing walk collects interleaved function-call items alongside
-        // their tool results to keep parallel outputs together.  Move those
-        // function-call items back to the warmup so the server receives them
-        // as history (generate: false) and can pair them with the tool results
-        // that arrive in the delta request.
-        const deltaInput = [];
-        for (const item of rawDelta) {
-            if (isToolResultItem(item)) {
-                deltaInput.push(item);
-            }
-            else if (isToolContinuationItem(item)) {
-                warmupItems.push(item);
-            }
-            else {
-                deltaInput.push(item);
-            }
-        }
-        return {
-            warmupRequest: withProviderOptions({
-                ...replayRequest,
-                input: warmupItems,
-            }, { generate: false }),
-            request: {
-                ...replayRequest,
-                input: deltaInput,
-            },
-        };
-    }
-    #withCodexPreviousResponseId(request, previousResponseId) {
-        if (!previousResponseId) {
-            return request;
-        }
-        return this.#prepareCodexServerHistoryRequest({
-            ...request,
-            previousResponseId,
-        });
-    }
-    #rememberCodexResponseId(responseId, output, input, recordChainAnchor = false) {
+        return { request: input === request.input ? request : { ...request, input } };
+    }
+    /**
+     * Records a response ID as the anchor for the next turn's `previous_response_id`.
+     *
+     * The chain anchor -- the set of function call IDs a response is known to hold
+     * -- is recorded only for a full-history request, meaning one sent without
+     * `previous_response_id`. That condition used to be implicit: only the
+     * `generate:false` warmup leg recorded an anchor, and warmup always carried
+     * complete history. Recording it from a chained request instead would be a
+     * false-positive machine, because a chained request's `input` is only the
+     * delta -- the orphan guard below would then reject every genuinely new tool
+     * output as unknown to the chain.
+     */
+    #rememberCodexResponseId(responseId, output, input, sentAsFullHistory = false) {
         if (!responseId) {
             return;
         }
@@ -1012,8 +1121,13 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         const key = this.#getCodexServerHistoryKey();
         if (key) {
             this.codexPreviousResponseIds.set(key, responseId);
+            this.#lastLogicalRequestByKey.set(key, {
+                input: Array.isArray(input) ? [...input] : this.#lastLogicalRequestByKey.get(key)?.input ?? [],
+                output: Array.isArray(output) ? [...output] : [],
+                responseId,
+            });
         }
-        if (recordChainAnchor && (Array.isArray(output) || Array.isArray(input))) {
+        if (sentAsFullHistory && (Array.isArray(output) || Array.isArray(input))) {
             this.codexFunctionCallIdsByResponseId.set(responseId, new Set([...collectFunctionCallIds(output), ...collectFunctionCallIds(input)]));
         }
     }
@@ -1061,6 +1175,36 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         this.codexFunctionCallIdsByResponseId.clear();
         this.codexTurnIdsBySession.clear();
         this.chainedWireState.clear();
+        this.#lastLogicalRequestByKey.clear();
+        this.#lastSentChainFingerprint = undefined;
+    }
+    #fingerprintPreparedRequest(request, recoveryClass = 'chain_recovery') {
+        return fingerprintChainRequest({
+            provider: 'codex',
+            model: this.modelId,
+            previousResponseId: typeof request?.previousResponseId === 'string' ? request.previousResponseId : null,
+            input: Array.isArray(request?.input) ? request.input : [],
+            recoveryClass,
+        });
+    }
+    #assertChainRequestMakesProgress(request) {
+        const fingerprint = this.#fingerprintPreparedRequest(request);
+        if (this.#lastRejectedChainFingerprint && this.#lastRejectedChainFingerprint === fingerprint) {
+            this.diagnosticLogger?.warn?.('Codex chain recovery would repeat a rejected request', {
+                eventType: 'retry.conversation_state_no_progress',
+                category: 'retry',
+                phase: 'request_prepare',
+            });
+            throw new ConversationStateNoProgressError();
+        }
+        this.#lastSentChainFingerprint = fingerprint;
+    }
+    #recordRejectedChainRequest(error) {
+        if (isMissingServerToolOutputError(error) ||
+            isOrphanedChainedToolOutputError(error) ||
+            isPreviousResponseNotFoundError(error)) {
+            this.#lastRejectedChainFingerprint = this.#lastSentChainFingerprint;
+        }
     }
     #shouldForgetCodexServerHistory(error) {
         // This rejects the new request before generation; it expires the socket,
@@ -1072,6 +1216,8 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         const message = getErrorMessage(error);
         return (isPreviousResponseNotFoundError(error) ||
             message.includes('previous_response_not_found') ||
+            isMissingServerToolOutputError(error) ||
+            isOrphanedChainedToolOutputError(error) ||
             isRetryableTransportError(error).transportFallback);
     }
     #getCodexServerHistoryKey() {
@@ -1084,7 +1230,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             return undefined;
         }
         const sessionContext = this.sessionContextService?.getContext();
-        const sessionId = sessionContext?.sessionId ?? requestId;
+        const sessionId = sessionContext?.providerHistoryKey ?? sessionContext?.sessionId ?? requestId;
         const threadId = sessionId;
         const hasPreviousResponseId = typeof request?.previousResponseId === 'string' && request.previousResponseId.length > 0;
         const turnId = hasPreviousResponseId ? this.codexTurnIdsBySession.get(sessionId) ?? randomUUID() : randomUUID();
@@ -1121,14 +1267,6 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             },
         };
     }
-    #getEffectiveCodexRequestAfterWarmup(originalRequest, preparedRequest, warmupResponseId) {
-        if (!preparedRequest.warmupRequest) {
-            return preparedRequest.request;
-        }
-        return warmupResponseId
-            ? this.#withCodexPreviousResponseId(preparedRequest.request, warmupResponseId)
-            : originalRequest;
-    }
     #withoutCodexServerHistory(request) {
         if (!request || typeof request !== 'object') {
             return request;
@@ -1141,16 +1279,17 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             let attemptedWithServerHistory = false;
             try {
                 const preparedRequest = this.#prepareCodexServerHistoryRequests(request);
-                attemptedWithServerHistory = Boolean(preparedRequest.warmupRequest || preparedRequest.request?.previousResponseId);
-                const warmupResponseId = await this.#warmupCodexUnary(preparedRequest.warmupRequest);
-                const effectiveRequest = this.#getEffectiveCodexRequestAfterWarmup(request, preparedRequest, warmupResponseId);
+                attemptedWithServerHistory = Boolean(preparedRequest.request?.previousResponseId);
+                const effectiveRequest = preparedRequest.request;
+                this.#assertChainRequestMakesProgress(effectiveRequest);
                 const response = await super.fetchUnaryResponse(effectiveRequest);
                 const responseId = getResponseIdFromResponse(response);
-                this.#rememberCodexResponseId(responseId, asRecord(response)?.output, effectiveRequest.input);
+                this.#rememberCodexResponseId(responseId, asRecord(response)?.output, request.input, !effectiveRequest.previousResponseId);
                 this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
                 return response;
             }
             catch (error) {
+                this.#recordRejectedChainRequest(error);
                 if (isPreviousResponseUnavailableError(error) && attemptedWithServerHistory) {
                     this.#forgetCodexResponseId();
                     if (isPreviousResponseUnavailableError(error) && hasToolResultInput(request)) {
@@ -1159,7 +1298,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                     const fallbackRequest = this.#withoutCodexServerHistory(request);
                     const response = await super.fetchUnaryResponse(fallbackRequest);
                     const responseId = getResponseIdFromResponse(response);
-                    this.#rememberCodexResponseId(responseId, asRecord(response)?.output, fallbackRequest.input);
+                    this.#rememberCodexResponseId(responseId, asRecord(response)?.output, fallbackRequest.input, true);
                     this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
                     return response;
                 }
@@ -1176,15 +1315,15 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         let attemptedWithServerHistory = false;
         try {
             const preparedRequest = this.#prepareCodexServerHistoryRequests(request);
-            attemptedWithServerHistory = Boolean(preparedRequest.warmupRequest || preparedRequest.request?.previousResponseId);
-            const warmupResponseId = await this.#warmupCodexStream(preparedRequest.warmupRequest);
-            const effectiveRequest = this.#getEffectiveCodexRequestAfterWarmup(request, preparedRequest, warmupResponseId);
+            attemptedWithServerHistory = Boolean(preparedRequest.request?.previousResponseId);
+            const effectiveRequest = preparedRequest.request;
+            this.#assertChainRequestMakesProgress(effectiveRequest);
             let responseId;
             for await (const event of super.rawStream(effectiveRequest)) {
                 const eventResponseId = getResponseIdFromStreamEvent(event);
                 if (eventResponseId) {
                     responseId = eventResponseId;
-                    this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), effectiveRequest.input);
+                    this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), request.input, !effectiveRequest.previousResponseId);
                 }
                 if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type)) {
                     this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
@@ -1195,6 +1334,8 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
         }
         catch (error) {
+            this.#logWebSocketClosedEarly(error, receivedRawFrame);
+            this.#recordRejectedChainRequest(error);
             if (isPreviousResponseUnavailableError(error) && attemptedWithServerHistory && !receivedRawFrame) {
                 this.#forgetCodexResponseId();
                 if (isPreviousResponseUnavailableError(error) && hasToolResultInput(request)) {
@@ -1208,7 +1349,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         const eventResponseId = getResponseIdFromStreamEvent(event);
                         if (eventResponseId) {
                             responseId = eventResponseId;
-                            this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), fallbackRequest.input);
+                            this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), fallbackRequest.input, true);
                         }
                         if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type)) {
                             this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
@@ -1228,6 +1369,27 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             throw asAmbiguousModelOutcome(error) ?? error;
         }
     }
+    /**
+     * The close code is the only field that distinguishes a network drop from a
+     * deliberate server close, and it is discarded once the error is wrapped for
+     * recovery. Record it here, where the retry decision that follows can be read
+     * against it.
+     */
+    #logWebSocketClosedEarly(error, receivedRawFrame) {
+        const closed = findWebSocketClosedEarly(error);
+        if (!closed)
+            return;
+        this.diagnosticLogger?.warn?.('Codex WebSocket closed before a terminal response event', {
+            eventType: 'codex.websocket.closed_early',
+            category: 'provider',
+            model: this.modelId,
+            closeCode: closed.closeCode ?? null,
+            closeReason: closed.closeReason ?? null,
+            unsentCount: closed.unsentCount,
+            receivedRawFrame,
+            provablyUnsent: error instanceof UnsentWebSocketRequestError,
+        });
+    }
     buildResponsesCreateRequest(request, stream) {
         const built = super.buildResponsesCreateRequest(request, stream);
         const requestData = normalizeCodexRequestData(built.requestData, request, this.modelId, {
@@ -1311,13 +1473,14 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 if (wireStateKey && wireStateToken && typeof response?.id === 'string' && response.id.length > 0) {
                     this.chainedWireState.recordResponse(wireStateKey, wireStateToken, response.id, response.output);
                 }
-                this.#logTrafficReceived(requestId, requestData, response);
+                this.#logTrafficReceived(requestId, requestData, response, watchdog.receiveTiming());
                 return response;
             }
             catch (error) {
                 const timeoutError = watchdog.timeoutError();
+                const receiveTiming = watchdog.receiveTiming();
                 watchdog.close();
-                const failure = timeoutError ?? error;
+                const failure = asProvablyUnsentTimeout(timeoutError, receiveTiming, updatedRequest) ?? timeoutError ?? error;
                 if (wireStateKey) {
                     if (isWebSocketConnectionLimitReachedError(failure)) {
                         if (wireStateToken)
@@ -1327,19 +1490,20 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         this.chainedWireState.invalidate(wireStateKey);
                     }
                 }
-                this.#logTrafficFailed(requestId, requestData, failure);
+                this.#logTrafficFailed(requestId, requestData, failure, receiveTiming);
                 throw failure;
             }
         }
         try {
             const response = (await super.fetchResponse(updatedRequest, stream));
             const patched = wrapCodexStream(watchdog.wrap(response), this.diagnosticLogger);
-            return this.#withTrafficLogging(patched, requestId, requestData, wireStateKey, wireStateToken, updatedRequest.signal);
+            return this.#withTrafficLogging(patched, requestId, requestData, wireStateKey, wireStateToken, updatedRequest.signal, () => watchdog.receiveTiming(), () => asProvablyUnsentTimeout(watchdog.timeoutError(), watchdog.receiveTiming(), updatedRequest));
         }
         catch (error) {
             const timeoutError = watchdog.timeoutError();
+            const receiveTiming = watchdog.receiveTiming();
             watchdog.close();
-            const failure = timeoutError ?? error;
+            const failure = asProvablyUnsentTimeout(timeoutError, receiveTiming, updatedRequest) ?? timeoutError ?? error;
             if (wireStateKey) {
                 if (isWebSocketConnectionLimitReachedError(failure)) {
                     if (wireStateToken)
@@ -1349,7 +1513,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                     this.chainedWireState.invalidate(wireStateKey);
                 }
             }
-            this.#logTrafficFailed(requestId, requestData, failure);
+            this.#logTrafficFailed(requestId, requestData, failure, receiveTiming);
             throw failure;
         }
     }