@qduc/term2 0.21.0 → 0.22.0

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

@@ -6,6 +6,7 @@ import { sanitizeHeaders } from '../utils/header-sanitizer.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 { isClassifiedCancellation } from '../services/retry/provider-failure-classification.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';
@@ -88,7 +89,7 @@ export class CodexResponsesTransport {
         const stream = await this.client.responses.create({
             model: this.model,
             input: [...request.input, { type: 'compaction_trigger' }],
-            parallel_tool_calls: true,
+            parallel_tool_calls: !isCodexResponsesLiteModel(this.model),
             stream: true,
             store: false,
             include: ['reasoning.encrypted_content'],
@@ -149,14 +150,23 @@ export class CodexResponsesTransport {
             },
         };
     }
-    async fetchResponse(request, stream, requestData) {
+    async fetchResponse(request, stream, requestData, requestContext) {
         try {
             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 = this.#sessions.acquire(headers);
+                const affinityKey = typeof request.codex?.promptCacheKey === 'string' && request.codex.promptCacheKey.length > 0
+                    ? request.codex.promptCacheKey
+                    : undefined;
+                const acquisition = this.#sessions.acquireWithMetadata(headers, { affinityKey });
+                const socket = acquisition.socket;
+                requestContext?.onConnectionAcquired?.({
+                    connectionId: acquisition.connectionId,
+                    reused: acquisition.reused,
+                    ...(affinityKey ? { affinityKey } : {}),
+                });
                 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
@@ -208,6 +218,12 @@ export class CodexResponsesTransport {
                                 const event = message.message;
                                 if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type) || event?.type === 'response.completed') {
                                     terminalReceived = true;
+                                    // The terminal frame proves this lease is no longer in
+                                    // flight. Release before yielding it: the application can
+                                    // settle a rollover immediately after observing the
+                                    // terminal event, before this generator is resumed for its
+                                    // finally block.
+                                    release(true);
                                 }
                                 yield event;
                             }
@@ -215,6 +231,7 @@ export class CodexResponsesTransport {
                                 const event = message.event;
                                 if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type) || event?.type === 'response.completed') {
                                     terminalReceived = true;
+                                    release(true);
                                 }
                                 yield event;
                             }
@@ -285,9 +302,9 @@ export class OpenAIResponsesModel {
         }
         return built;
     }
-    async fetchResponse(request, stream) {
+    async fetchResponse(request, stream, requestContext) {
         const built = this.buildResponsesCreateRequest(request, stream);
-        return this.transport.fetchResponse(request, stream, built.requestData);
+        return this.transport.fetchResponse(request, stream, built.requestData, requestContext);
     }
     async fetchUnaryResponse(request) {
         return this.fetchResponse(request, false);
@@ -1015,6 +1032,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
     #lastSentChainFingerprint;
     #lastRejectedChainFingerprint;
     #lastLogicalRequestByKey = new Map();
+    #transportDiagnosticsByRequest = new WeakMap();
     providerTraffic;
     diagnosticLogger;
     sessionContextService;
@@ -1048,10 +1066,31 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 : websocketReceiveTimeouts;
         this.requestCapture = requestCapture instanceof CodexResponsesTransport ? undefined : requestCapture;
     }
+    /**
+     * Drop server-history bookkeeping for one logical scope while leaving the
+     * provider transport pool alive. Rollover supplies the predecessor key;
+     * refusing an unscoped reset protects live nested scopes sharing this model.
+     */
+    resetConversationState(options) {
+        if (!options?.providerHistoryKey)
+            return;
+        this.#forgetCodexServerHistoryForKey(options.providerHistoryKey);
+    }
+    #transportDiagnostics(request) {
+        return this.#transportDiagnosticsByRequest.get(request);
+    }
+    async compactHistory(request) {
+        const result = await super.compactHistory(request);
+        // A native compaction item replaces the provider's prior transcript. The
+        // old Responses-Lite chain may still contain an unfinished function call,
+        // so retaining it would combine the checkpoint with stale server debt.
+        this.#forgetCodexServerHistoryForCurrentKey();
+        return result;
+    }
     #modelNameFallback() {
         return this.modelId;
     }
-    #logTrafficStarted(requestId, requestData, headers) {
+    #logTrafficStarted(requestId, requestData, headers, transportDiagnostics) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         const sanitizedHeaders = headers ? sanitizeHeaders(headers) : undefined;
@@ -1061,11 +1100,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             model,
             sentBody: requestData,
             headers: sanitizedHeaders,
+            transportDiagnostics,
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficReceived(requestId, requestData, response, receiveTiming) {
+    #logTrafficReceived(requestId, requestData, response, receiveTiming, transportDiagnostics) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordResponseReceived({
@@ -1076,11 +1116,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             response: response,
             transport: 'websocket',
             ...(receiveTiming ? { receiveTiming } : {}),
+            transportDiagnostics,
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficFailed(requestId, requestData, error, receiveTiming, diagnostics) {
+    #logTrafficFailed(requestId, requestData, error, receiveTiming, diagnostics, transportDiagnostics) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordRequestFailed({
@@ -1090,11 +1131,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             error,
             ...(receiveTiming ? { receiveTiming } : {}),
             ...(diagnostics ? { diagnostics } : {}),
+            transportDiagnostics,
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    #logTrafficClosed(requestId, requestData, outcome, eventCount, diagnostics) {
+    #logTrafficClosed(requestId, requestData, outcome, eventCount, diagnostics, transportDiagnostics) {
         const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
         const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
         providerTraffic.recordResponseClosed({
@@ -1104,11 +1146,12 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             outcome,
             eventCount,
             ...(diagnostics ? { diagnostics } : {}),
+            transportDiagnostics,
             modelClass: WS_RESPONSE_MODEL_CLASS,
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken, signal, receiveTiming, asProvablyUnsent) {
+    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken, signal, receiveTiming, asProvablyUnsent, transportDiagnostics) {
         const logReceived = this.#logTrafficReceived.bind(this);
         const logFailed = this.#logTrafficFailed.bind(this);
         const logClosed = this.#logTrafficClosed.bind(this);
@@ -1141,7 +1184,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         if (wireStateKey && wireStateToken && typeof response.id === 'string' && response.id.length > 0) {
                             wireState.recordResponse(wireStateKey, wireStateToken, response.id, response.output);
                         }
-                        logReceived(requestId, requestData, response, receiveTiming?.());
+                        logReceived(requestId, requestData, response, receiveTiming?.(), transportDiagnostics);
                     }
                     yield event;
                 }
@@ -1156,21 +1199,21 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 // reached the wire; the wire-state decision above still keys off the
                 // error as thrown.
                 const failure = asProvablyUnsent?.(error) ?? error;
-                if (signal?.aborted && eventCount > 0) {
+                if (signal?.aborted && eventCount > 0 && isClassifiedCancellation(failure)) {
                     // An active request can reject from the provider as soon as the
                     // application's abort reaches the socket. Preserve the partial raw
                     // transcript in the same aborted outcome used when the consumer
                     // closes the iterator explicitly; otherwise a guard-triggered abort
                     // would be reduced to bounded counters before the recorder's
                     // finally block can retain it.
-                    logClosed(requestId, requestData, 'aborted', eventCount, recorder.diagnostics());
+                    logClosed(requestId, requestData, 'aborted', eventCount, recorder.diagnostics(), transportDiagnostics);
                 }
                 else {
                     // Bounded evidence of whatever progress the recorder observed before
                     // the failure (category/counter/timing, no raw frame payload) — a
                     // stream that fails after thousands of frames (e.g. an abrupt close)
                     // must not lose that evidence the way an unrecorded failure would.
-                    logFailed(requestId, requestData, failure, receiveTiming?.(), recorder.boundedDiagnostics());
+                    logFailed(requestId, requestData, failure, receiveTiming?.(), recorder.boundedDiagnostics(), transportDiagnostics);
                 }
                 throw failure;
             }
@@ -1189,7 +1232,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         ? recorder.diagnostics()
                         : outcome === 'failed'
                             ? recorder.boundedDiagnostics()
-                            : undefined);
+                            : undefined, transportDiagnostics);
                 }
                 recorder.release();
                 if (wireStateKey && wireStateToken) {
@@ -1347,6 +1390,23 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (previousResponseId)
             this.codexConsumedToolResultCallIdsByResponseId.set(previousResponseId, consumed);
     }
+    #forgetCodexServerHistoryForCurrentKey() {
+        this.#forgetCodexServerHistoryForKey(this.#getCodexServerHistoryKey());
+    }
+    #forgetCodexServerHistoryForKey(key) {
+        if (!key)
+            return;
+        const responseId = this.chainedWireState.getStoredResponseId(key);
+        this.chainedWireState.invalidate(key);
+        this.codexPreviousResponseIds.delete(key);
+        this.codexTurnIdsBySession.delete(key);
+        this.#lastLogicalRequestByKey.delete(key);
+        if (responseId) {
+            this.codexConsumedToolResultCallIdsByResponseId.delete(responseId);
+            this.codexFunctionCallIdsByResponseId.delete(responseId);
+        }
+        this.#lastSentChainFingerprint = undefined;
+    }
     #forgetCodexResponseId() {
         this.#serverHistoryReuseDisabled = true;
         this.codexPreviousResponseIds.clear();
@@ -1423,39 +1483,47 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             return undefined;
         }
         const sessionContext = this.sessionContextService?.getContext();
-        const sessionId = sessionContext?.providerHistoryKey ?? sessionContext?.sessionId ?? requestId;
-        const threadId = sessionId;
+        const logicalSessionId = sessionContext?.providerHistoryKey ?? sessionContext?.sessionId ?? requestId;
+        // WebSocket handshake headers cannot change after a socket is opened. Use
+        // the root cache affinity for that physical identity, while the per-frame
+        // client metadata below continues to identify the current logical scope.
+        // The backend's treatment of these two identity channels is not assumed;
+        // the distinction is kept explicit in tests and telemetry.
+        const transportSessionId = request.codex?.promptCacheKey ?? sessionContext?.promptCacheKey ?? logicalSessionId;
+        const threadId = logicalSessionId;
         const hasPreviousResponseId = typeof request?.previousResponseId === 'string' && request.previousResponseId.length > 0;
-        const turnId = hasPreviousResponseId ? this.codexTurnIdsBySession.get(sessionId) ?? randomUUID() : randomUUID();
-        this.codexTurnIdsBySession.set(sessionId, turnId);
+        const turnId = hasPreviousResponseId
+            ? this.codexTurnIdsBySession.get(logicalSessionId) ?? randomUUID()
+            : randomUUID();
+        this.codexTurnIdsBySession.set(logicalSessionId, turnId);
         const windowId = `${threadId}:1`;
         const turnMetadata = JSON.stringify({
             installation_id: installationId,
-            session_id: sessionId,
+            session_id: logicalSessionId,
             thread_id: threadId,
             turn_id: turnId,
             window_id: windowId,
             request_kind: 'turn',
         });
         return {
-            sessionId,
+            sessionId: logicalSessionId,
             threadId,
             turnId,
             windowId,
             turnMetadata,
             clientMetadata: {
                 'x-codex-installation-id': installationId,
-                session_id: sessionId,
+                session_id: logicalSessionId,
                 thread_id: threadId,
                 'x-codex-window-id': windowId,
                 turn_id: turnId,
                 'x-codex-turn-metadata': turnMetadata,
             },
             headers: {
-                'x-client-request-id': threadId,
-                'session-id': sessionId,
-                'thread-id': threadId,
-                'x-codex-window-id': windowId,
+                'x-client-request-id': transportSessionId,
+                'session-id': transportSessionId,
+                'thread-id': transportSessionId,
+                'x-codex-window-id': transportSessionId + ':1',
                 'x-codex-turn-metadata': turnMetadata,
             },
         };
@@ -1676,14 +1744,28 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         // transport's private fetch path. Capture it without changing the
         // prepared request or wire state.
         captureProviderRequest(this.requestCapture, { provider: 'codex', transport: 'websocket', requestData });
-        this.#logTrafficStarted(requestId, requestData, extraHeaders);
+        const transportDiagnostics = {
+            ...(request.codex?.promptCacheKey ?? this.sessionContextService?.getContext()?.promptCacheKey
+                ? {
+                    affinityKey: request.codex?.promptCacheKey ?? this.sessionContextService?.getContext()?.promptCacheKey,
+                }
+                : {}),
+            ...(this.#getCodexServerHistoryKey() ? { logicalHistoryKey: this.#getCodexServerHistoryKey() } : {}),
+        };
+        this.#logTrafficStarted(requestId, requestData, extraHeaders, transportDiagnostics);
         if (!stream) {
             try {
-                const response = await fetchAndReconstructUnaryResponse(async () => watchdog.wrap(await super.fetchResponse(updatedRequest, true)), this.diagnosticLogger);
+                const response = await fetchAndReconstructUnaryResponse(async () => watchdog.wrap(await super.fetchResponse(updatedRequest, true, {
+                    onConnectionAcquired: (details) => this.#transportDiagnosticsByRequest.set(updatedRequest, {
+                        ...transportDiagnostics,
+                        connectionId: details.connectionId,
+                        reused: details.reused,
+                    }),
+                })), this.diagnosticLogger);
                 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, watchdog.receiveTiming());
+                this.#logTrafficReceived(requestId, requestData, response, watchdog.receiveTiming(), this.#transportDiagnostics(updatedRequest));
                 return response;
             }
             catch (error) {
@@ -1700,15 +1782,21 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         this.chainedWireState.invalidate(wireStateKey);
                     }
                 }
-                this.#logTrafficFailed(requestId, requestData, failure, receiveTiming);
+                this.#logTrafficFailed(requestId, requestData, failure, receiveTiming, undefined, this.#transportDiagnostics(updatedRequest));
                 throw failure;
             }
         }
         try {
-            const response = (await super.fetchResponse(updatedRequest, stream));
+            const response = (await super.fetchResponse(updatedRequest, stream, {
+                onConnectionAcquired: (details) => this.#transportDiagnosticsByRequest.set(updatedRequest, {
+                    ...transportDiagnostics,
+                    connectionId: details.connectionId,
+                    reused: details.reused,
+                }),
+            }));
             const patched = wrapCodexStream(watchdog.wrap(response), this.diagnosticLogger);
             return this.#withTrafficLogging(patched, requestId, requestData, wireStateKey, wireStateToken, updatedRequest.signal, () => watchdog.receiveTiming(), (error) => asProvablyUnsentTimeout(watchdog.timeoutError(), watchdog.receiveTiming(), updatedRequest) ??
-                asProvablyUnsentConnectTimeout(error, updatedRequest, watchdog.receiveTiming().frameCount > 0));
+                asProvablyUnsentConnectTimeout(error, updatedRequest, watchdog.receiveTiming().frameCount > 0), this.#transportDiagnostics(updatedRequest));
         }
         catch (error) {
             const timeoutError = watchdog.timeoutError();
@@ -1724,7 +1812,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                     this.chainedWireState.invalidate(wireStateKey);
                 }
             }
-            this.#logTrafficFailed(requestId, requestData, failure, receiveTiming);
+            this.#logTrafficFailed(requestId, requestData, failure, receiveTiming, undefined, this.#transportDiagnostics(updatedRequest));
             throw failure;
         }
     }