@qduc/term2 0.11.1 → 0.13.0

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

@@ -1,18 +1,324 @@
-import { OpenAIResponsesModel, OpenAIResponsesWSModel } from '@openai/agents-openai';
-import { getCurrentTrace, withTrace } from '@openai/agents-core';
 import { randomUUID } from 'node:crypto';
+import { ResponsesWS } from 'openai/resources/responses/ws';
+import OpenAI from 'openai';
+import { toCodexResponsesInput } from './codex-turn-converter.js';
 import { sanitizeHeaders } from '../utils/header-sanitizer.js';
-import { dropUnpairedFunctionCalls } from '../services/tool-execution-ledger.js';
+import { OrphanedChainedToolOutputError } from '../lib/chained-input-filter.js';
 import { AmbiguousModelOutcomeError } from '../services/retry/retry-errors.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';
 const DUMMY_PROVIDER_TRAFFIC = {
     recordRequestStart() { },
     async recordResponseReceived() { },
+    recordResponseClosed() { },
     recordRequestFailed() { },
 };
-import { isPreviousResponseNotFoundError, isRetryableTransportError, } from '../services/retry/retry-error-classification.js';
+function toCodexToolChoice(choice) {
+    if (choice === 'auto' || choice === 'required' || choice === 'none')
+        return choice;
+    if (choice && typeof choice === 'object' && typeof choice.name === 'string') {
+        return { type: 'function', name: choice.name };
+    }
+    throw new Error('Unsupported Codex tool choice.');
+}
+/** Provider-owned transport seam used by Codex's HTTP and WebSocket models. */
+export class CodexResponsesTransport {
+    client;
+    model;
+    websocket;
+    constructor(client = {}, model = '', websocket = false) {
+        this.client = client;
+        this.model = model;
+        this.websocket = websocket;
+    }
+    buildResponsesCreateRequest(request, stream) {
+        const providerOptions = request.providerOptions ?? {};
+        const { extraBody, extraHeaders: _extraHeaders, ...nativeProviderData } = providerOptions;
+        return {
+            requestData: {
+                model: this.model,
+                input: toCodexResponsesInput(request.input),
+                stream,
+                ...(request.instructions !== undefined ? { instructions: request.instructions } : {}),
+                ...(request.tools.length > 0 ? { tools: request.tools.map((tool) => ({ type: 'function', ...tool })) } : {}),
+                ...(request.toolChoice !== undefined ? { tool_choice: toCodexToolChoice(request.toolChoice) } : {}),
+                ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+                ...(request.topP !== undefined ? { top_p: request.topP } : {}),
+                ...(request.frequencyPenalty !== undefined ? { frequency_penalty: request.frequencyPenalty } : {}),
+                ...(request.presencePenalty !== undefined ? { presence_penalty: request.presencePenalty } : {}),
+                ...(request.maxTokens !== undefined ? { max_output_tokens: request.maxTokens } : {}),
+                ...(request.reasoning !== undefined ? { reasoning: request.reasoning } : {}),
+                ...nativeProviderData,
+                ...(extraBody ?? {}),
+                ...(request.previousResponseId ? { previous_response_id: request.previousResponseId } : {}),
+                ...(request.codex?.promptCacheKey ? { prompt_cache_key: request.codex.promptCacheKey } : {}),
+                ...(request.codex?.include ? { include: request.codex.include } : {}),
+            },
+        };
+    }
+    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.');
+                    }
+                }
+                finally {
+                    try {
+                        socket.close();
+                    }
+                    catch {
+                        /* best effort */
+                    }
+                }
+            })();
+        }
+        return this.client.responses.create(requestData, {
+            ...(request.signal ? { signal: request.signal } : {}),
+            ...(request.providerOptions?.extraHeaders ? { headers: request.providerOptions.extraHeaders } : {}),
+        });
+    }
+}
+export class OpenAIResponsesModel {
+    client;
+    model;
+    transport;
+    constructor(client, model, transport, websocket = false) {
+        this.client = client;
+        this.model = model;
+        this.transport = transport ?? new CodexResponsesTransport(client, model, websocket);
+    }
+    buildResponsesCreateRequest(request, stream) {
+        const built = this.transport.buildResponsesCreateRequest(request, stream);
+        if (this.transport instanceof CodexResponsesTransport && built?.requestData) {
+            built.requestData.model = this.model;
+        }
+        return built;
+    }
+    async fetchResponse(request, stream) {
+        const built = this.buildResponsesCreateRequest(request, stream);
+        return this.transport.fetchResponse(request, stream, built.requestData);
+    }
+    async fetchUnaryResponse(request) {
+        return this.fetchResponse(request, false);
+    }
+    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;
+        }
+    }
+    async *stream(request) {
+        yield* convertCodexRawStream(this.rawStream(request));
+    }
+}
+export class OpenAIResponsesWSModel extends OpenAIResponsesModel {
+    constructor(client, model, transport) {
+        super(client, model, transport, true);
+    }
+}
+async function* convertCodexRawStream(source) {
+    const output = [];
+    const pendingToolCalls = [];
+    const terminalReasoning = [];
+    const toolNamesByIndex = new Map();
+    const toolArgumentLengthsByIndex = new Map();
+    let sawReasoningDelta = false;
+    let responseId = '';
+    let finishReason;
+    let usage;
+    let sawCompletedResponse = false;
+    for await (const event of source) {
+        if (event?.type === 'codex.rate_limits') {
+            const rateLimits = event.rate_limits ?? event;
+            if (rateLimits && typeof rateLimits === 'object')
+                yield { type: 'codex_rate_limits', rateLimits };
+        }
+        else if (event?.type === 'response.output_text.delta') {
+            yield { type: 'text_delta', text: String(event.delta ?? '') };
+        }
+        else if (event?.type === 'response.reasoning_summary_text.delta') {
+            const text = String(event.delta ?? '');
+            if (text) {
+                sawReasoningDelta = true;
+                yield {
+                    type: 'reasoning_delta',
+                    ...(typeof event.item_id === 'string' ? { id: event.item_id } : {}),
+                    text,
+                };
+            }
+        }
+        else if (event?.type === 'response.output_item.added' && event.output_item?.type === 'function_call') {
+            const index = typeof event.output_index === 'number' ? event.output_index : event.output_item.id ?? 0;
+            if (typeof event.output_item.name === 'string')
+                toolNamesByIndex.set(index, event.output_item.name);
+            toolArgumentLengthsByIndex.set(index, 0);
+        }
+        else if ((event?.type === 'response.function_call_arguments.delta' ||
+            event?.type === 'response.custom_tool_call_input.delta' ||
+            event?.type === 'response.mcp_call_arguments.delta') &&
+            typeof event.delta === 'string' &&
+            event.delta) {
+            const index = typeof event.output_index === 'number' ? event.output_index : event.item_id ?? 0;
+            const argumentCharCount = (toolArgumentLengthsByIndex.get(index) ?? 0) + event.delta.length;
+            toolArgumentLengthsByIndex.set(index, argumentCharCount);
+            const toolName = toolNamesByIndex.get(index);
+            yield { type: 'tool_call_streaming_delta', ...(toolName ? { toolName } : {}), argumentCharCount };
+        }
+        else if (event?.type === 'response.output_item.done' && event.item?.type === 'function_call') {
+            const call = toCodexToolCallOutput(event.item);
+            output.push(call);
+            pendingToolCalls.push(call);
+        }
+        else if (event?.type === 'response.completed') {
+            sawCompletedResponse = true;
+            responseId = codexString(event.response?.id) ?? responseId;
+            finishReason = codexString(event.response?.status) ?? codexString(event.response?.incomplete_details?.reason);
+            usage = toCodexUsage(event.response?.usage);
+            for (const item of event.response?.output ?? []) {
+                const converted = toCodexOutputItem(item);
+                if (converted.type !== 'tool_call') {
+                    output.push(converted);
+                    if (converted.type === 'reasoning')
+                        terminalReasoning.push(converted);
+                }
+            }
+            const authoritativeReasoning = sawReasoningDelta ? [] : terminalReasoning;
+            for (const reasoning of authoritativeReasoning) {
+                yield {
+                    type: 'reasoning_delta',
+                    ...(reasoning.id ? { id: reasoning.id } : {}),
+                    text: reasoning.text,
+                    ...(reasoning.providerMetadata ? { providerMetadata: reasoning.providerMetadata } : {}),
+                };
+            }
+            for (const call of pendingToolCalls)
+                yield call;
+            break;
+        }
+        else if (event?.type === 'response.incomplete' ||
+            event?.type === 'response.failed' ||
+            event?.type === 'response.error') {
+            const status = String(event.type).slice('response.'.length);
+            const message = event.response?.error?.message ?? event.error?.message ?? `Codex response ${status}`;
+            throw new Error(`Codex provider response ${status}: ${message}`);
+        }
+    }
+    if (!sawCompletedResponse)
+        throw new Error('Codex streamed response ended without a completed response event.');
+    if (!responseId)
+        throw new Error('Codex completed response did not include an id.');
+    yield {
+        type: 'completion',
+        responseId,
+        output,
+        ...(finishReason ? { finishReason } : {}),
+        ...(usage ? { usage } : {}),
+    };
+}
+function toCodexToolCallOutput(item) {
+    const id = codexString(item?.call_id) ?? codexString(item?.id);
+    const name = codexString(item?.name);
+    if (!id || !name)
+        throw new Error('Codex function call output is missing its call id or name.');
+    return { type: 'tool_call', id, name, arguments: typeof item.arguments === 'string' ? item.arguments : '{}' };
+}
+function toCodexOutputItem(item) {
+    if (!item || typeof item !== 'object')
+        throw new Error('Unsupported Codex response output item.');
+    if (item.type === 'function_call')
+        return toCodexToolCallOutput(item);
+    if (item.type === 'message') {
+        const content = Array.isArray(item.content) ? item.content : [];
+        return {
+            type: 'message',
+            content: content.map((part) => {
+                if (part?.type && !['output_text', 'input_text', 'text'].includes(part.type))
+                    throw new Error(`Unsupported Codex response message content: ${String(part.type)}.`);
+                if (typeof part?.text !== 'string')
+                    throw new Error('Unsupported Codex response message content without text.');
+                return { type: 'text', text: part.text };
+            }),
+        };
+    }
+    if (item.type === 'reasoning') {
+        return {
+            type: 'reasoning',
+            ...(codexString(item.id) ? { id: item.id } : {}),
+            text: codexReasoningText(item.summary ?? item.content ?? ''),
+            providerMetadata: { codex: codexReasoningMetadata(item) },
+        };
+    }
+    throw new Error(`Unsupported Codex response output item type: ${String(item.type)}.`);
+}
+function codexReasoningText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .map((part) => {
+        if (!part || typeof part !== 'object' || typeof part.text !== 'string')
+            throw new Error('Unsupported Codex reasoning content without text.');
+        return part.text;
+    })
+        .join('');
+}
+function codexReasoningMetadata(item) {
+    const { type: _type, id: _id, summary: _summary, content: _content, ...metadata } = item;
+    return metadata;
+}
+function toCodexUsage(rawUsage) {
+    if (!rawUsage || typeof rawUsage !== 'object')
+        return undefined;
+    const inputTokens = rawUsage.input_tokens ?? rawUsage.inputTokens;
+    const outputTokens = rawUsage.output_tokens ?? rawUsage.outputTokens;
+    if (inputTokens === undefined && outputTokens === undefined)
+        return undefined;
+    const cachedInputTokens = rawUsage.input_tokens_details?.cached_tokens ?? rawUsage.inputTokensDetails?.cachedTokens;
+    const cacheWriteTokens = rawUsage.input_tokens_details?.cache_write_tokens ?? rawUsage.inputTokensDetails?.cacheWriteTokens;
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(cacheWriteTokens !== undefined ? { cacheWriteTokens } : {}),
+    };
+}
+function codexString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+import { isIncompleteStreamTerminalError, 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',
@@ -53,23 +359,52 @@ function stripCodexReplayIds(input) {
 }
 function normalizeCodexRequestData(requestData, request, model, options = {}) {
     const normalizedRequestData = { ...requestData };
-    // Codex responses endpoint rejects temperature; always omit it.
+    // Codex responses endpoint rejects temperature and max_output_tokens; always omit them.
     if ('temperature' in normalizedRequestData) {
         delete normalizedRequestData.temperature;
     }
+    if ('max_output_tokens' in normalizedRequestData) {
+        delete normalizedRequestData.max_output_tokens;
+    }
     const hasPreviousResponseId = (typeof normalizedRequestData.previous_response_id === 'string' &&
         normalizedRequestData.previous_response_id.length > 0) ||
         (typeof request?.previousResponseId === 'string' && request.previousResponseId.length > 0);
     const normalizedInput = !hasPreviousResponseId && Array.isArray(normalizedRequestData.input)
-        ? dropUnpairedFunctionCalls(normalizedRequestData.input)
+        ? dropUnpairedCodexToolItems(normalizedRequestData.input)
         : normalizedRequestData.input;
-    normalizedRequestData.input = stripCodexReplayIds(normalizedInput);
-    const modelInclude = request?.modelSettings?.include;
+    normalizedRequestData.input = stripCodexReplayIds(Array.isArray(normalizedInput)
+        ? normalizedInput.map((item) => {
+            if (item?.type === 'function_call_result' || item?.type === 'function_call_output') {
+                // The Responses API rejects unknown parameters, so the camelCase
+                // spellings must be dropped, not just shadowed by the snake_case one
+                // added below — spreading `...item` alone leaves `callId` on the
+                // object alongside the new `call_id`.
+                const { callId: _callId, call_id: _call_id, tool_call_id: _toolCallId, ...rest } = item;
+                return {
+                    ...rest,
+                    type: 'function_call_output',
+                    call_id: item.call_id ?? item.callId ?? item.tool_call_id,
+                    // Responses supports rich function output content (input text,
+                    // images, and files). Preserve the already-normalized array;
+                    // only legacy object output needs JSON serialization.
+                    output: typeof item.output === 'string' || Array.isArray(item.output)
+                        ? item.output
+                        : JSON.stringify(item.output ?? ''),
+                };
+            }
+            if (item?.type === 'function_call' && item.callId && !item.call_id) {
+                const { callId: _callId, ...rest } = item;
+                return { ...rest, call_id: item.callId };
+            }
+            return item;
+        })
+        : normalizedInput);
+    const modelInclude = request?.codex?.include;
     if (Array.isArray(modelInclude) && modelInclude.length > 0) {
         const existingInclude = Array.isArray(normalizedRequestData.include) ? normalizedRequestData.include : [];
         normalizedRequestData.include = Array.from(new Set([...existingInclude, ...modelInclude].filter((entry) => typeof entry === 'string' && entry.length > 0)));
     }
-    const promptCacheKey = request?.modelSettings?.prompt_cache_key;
+    const promptCacheKey = request?.codex?.promptCacheKey;
     if (typeof promptCacheKey === 'string' && promptCacheKey.length > 0) {
         normalizedRequestData.prompt_cache_key = promptCacheKey;
     }
@@ -133,17 +468,13 @@ const summarizeReconstructedItems = (items) => {
 // Codex's `/backend-api/codex/responses` endpoint can ship terminal response
 // frames with either an empty `output` array or no `output` field at all, even
 // when the assistant message was already delivered via
-// `response.output_item.done`. The agents-SDK runner trusts terminal
-// `response.output` as the final output; when it is empty or missing it either
-// sees no items and re-runs the same request until maxTurns or crashes while
-// converting the terminal payload.
+// `response.output_item.done`. The application transport must treat the
+// terminal frame as authoritative; when it is empty or missing, retaining the
+// completed output items prevents a false empty completion.
 //
-// This wrapper subclasses `OpenAIResponsesModel`, overrides the streaming
-// fetch path, and patches the terminal frame in flight: it accumulates raw
-// items from `response.output_item.done` and, only when terminal
-// `response.output` is empty or missing, swaps in the accumulated items so the
-// parent's existing conversion logic (`convertToOutputItem`) produces a normal
-// `response_done` event.
+// The Codex transport accumulates raw items from `response.output_item.done`
+// and, only when terminal `response.output` is empty or missing, uses those
+// accumulated items for its application-owned completion event.
 const CODEX_SERVER_HISTORY_TOOL_RESULT_TYPES = new Set([
     'function_call_output',
     'function_call_result',
@@ -161,13 +492,16 @@ const normalizeCodexServerHistoryItem = (item) => {
     const record = asRecord(item);
     const type = stringValue(record?.type);
     const itemId = stringValue(record?.id);
-    const callId = stringValue(record?.call_id) ?? stringValue(record?.callId) ?? stringValue(record?.tool_call_id);
+    const callId = stringValue(record?.call_id) ??
+        stringValue(record?.callId) ??
+        stringValue(record?.tool_call_id) ??
+        (type === 'tool_call' || type === 'tool_result' ? stringValue(record?.id) : undefined);
     return {
         type,
         itemId,
         callId,
-        isFunctionCall: type === 'function_call',
-        isToolResult: typeof type === 'string' && CODEX_SERVER_HISTORY_TOOL_RESULT_TYPES.has(type),
+        isFunctionCall: type === 'function_call' || type === 'tool_call',
+        isToolResult: type === 'tool_result' || (typeof type === 'string' && CODEX_SERVER_HISTORY_TOOL_RESULT_TYPES.has(type)),
     };
 };
 const isUserInputMessage = (item) => asRecord(item)?.role === 'user';
@@ -190,17 +524,16 @@ const isToolContinuationItem = (item) => {
     return normalized.isFunctionCall && Boolean(normalized.itemId);
 };
 const findServerManagedDeltaStart = (input) => {
-    let trailingToolResultStart = input.length;
-    // Walk backward through tool-continuation items (tool results and
-    // their interleaved function calls) so parallel outputs from the same
-    // model response stay together in the delta instead of leaking into
-    // the warmup. Items without a call id (user messages, assistant
-    // messages, reasoning) naturally stop the walk.
-    while (trailingToolResultStart > 0 && isToolContinuationItem(input[trailingToolResultStart - 1])) {
-        trailingToolResultStart--;
-    }
-    if (trailingToolResultStart < input.length) {
-        return trailingToolResultStart;
+    let endUserIndex = input.length;
+    while (endUserIndex > 0 && isUserInputMessage(input[endUserIndex - 1])) {
+        endUserIndex--;
+    }
+    if (endUserIndex > 0 && isToolContinuationItem(input[endUserIndex - 1])) {
+        let toolStart = endUserIndex;
+        while (toolStart > 0 && isToolContinuationItem(input[toolStart - 1])) {
+            toolStart--;
+        }
+        return toolStart;
     }
     for (let index = input.length - 1; index >= 0; index--) {
         if (isUserInputMessage(input[index])) {
@@ -231,6 +564,45 @@ const collectToolResultCallIds = (input) => {
     }
     return ids;
 };
+const collectFunctionCallIds = (input) => {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    const ids = [];
+    for (const item of input) {
+        const normalized = normalizeCodexServerHistoryItem(item);
+        if (normalized.isFunctionCall && normalized.callId) {
+            ids.push(normalized.callId);
+        }
+    }
+    return ids;
+};
+const dropUnpairedCodexToolItems = (history) => {
+    const callIds = new Set();
+    const resultIds = new Set();
+    for (const item of history) {
+        const normalized = normalizeCodexServerHistoryItem(item);
+        if (!normalized.callId)
+            continue;
+        if (normalized.isFunctionCall)
+            callIds.add(normalized.callId);
+        if (normalized.isToolResult)
+            resultIds.add(normalized.callId);
+    }
+    if (callIds.size === 0 && resultIds.size === 0)
+        return history;
+    const filtered = history.filter((item) => {
+        const normalized = normalizeCodexServerHistoryItem(item);
+        if (!normalized.callId)
+            return true;
+        if (normalized.isFunctionCall)
+            return resultIds.has(normalized.callId);
+        if (normalized.isToolResult)
+            return callIds.has(normalized.callId);
+        return true;
+    });
+    return filtered.length === history.length ? history : filtered;
+};
 const filterServerManagedInput = (input, consumedToolResultCallIds) => {
     if (!Array.isArray(input)) {
         return input;
@@ -245,27 +617,24 @@ const filterServerManagedInput = (input, consumedToolResultCallIds) => {
     // function calls it issued). The request only needs the *new* items
     // produced since then.
     // Tool continuation: the input ends with a tool-call output answering the
-    // previous response's function call(s). A previous response may issue
-    // several parallel calls, and the reconstructed history pairs each call
-    // with its result (fc₁,fco₁,fc₂,fco₂,…) instead of grouping every output
-    // in one trailing block. Collect EVERY trailing tool-result item — walking
-    // back across tool results and their interleaved function calls (everything
-    // carrying a call id) — so the outputs for the earlier parallel calls are
-    // not dropped. Stopping at the first interleaved function call would send
-    // only the trailing output and the server rejects the request with a 400
-    // ("No tool output found for function call …"). The interleaved
-    // function-call items are then dropped because the server already holds
-    // them via previous_response_id.
-    if (isToolResultItem(input[input.length - 1])) {
-        let start = input.length - 1;
+    // previous response's function call(s) — or tool-call output(s) followed by
+    // user steer message(s) admitted mid-turn.
+    let endUserIndex = input.length;
+    while (endUserIndex > 0 && isUserInputMessage(input[endUserIndex - 1])) {
+        endUserIndex--;
+    }
+    if (endUserIndex > 0 && isToolResultItem(input[endUserIndex - 1])) {
+        let start = endUserIndex - 1;
         while (start > 0 && isToolContinuationItem(input[start - 1])) {
             start--;
         }
-        const trailing = input.slice(start);
+        const trailing = input.slice(start, endUserIndex);
         // A clean run of tool results (grouped layout) needs no filtering; for
         // the paired layout, drop the interleaved function-call items.
         const toolResults = trailing.every(isToolResultItem) ? trailing : trailing.filter(isToolResultItem);
-        return filterConsumedToolResults(toolResults, consumedToolResultCallIds);
+        const filteredToolResults = filterConsumedToolResults(toolResults, consumedToolResultCallIds);
+        const trailingUserMessages = input.slice(endUserIndex);
+        return [...filteredToolResults, ...trailingUserMessages];
     }
     // Fresh user turn with no trailing tool output: the delta is the latest
     // user message onward.
@@ -278,11 +647,21 @@ const getResponseIdFromResponse = (response) => {
     return typeof responseId === 'string' && responseId.length > 0 ? responseId : undefined;
 };
 const getResponseIdFromStreamEvent = (event) => {
-    const record = asRecord(event);
-    if (record?.type !== 'response_done') {
+    const candidate = asRecord(event);
+    if (!candidate ||
+        !['response.completed', 'response.incomplete', 'response.failed'].includes(String(candidate.type))) {
+        return undefined;
+    }
+    return getResponseIdFromResponse(candidate.response) ?? getResponseIdFromResponse(candidate);
+};
+const getResponseOutputFromStreamEvent = (event) => {
+    const candidate = asRecord(event);
+    if (!candidate ||
+        !['response.completed', 'response.incomplete', 'response.failed'].includes(String(candidate.type))) {
         return undefined;
     }
-    return getResponseIdFromResponse(record.response) ?? getResponseIdFromResponse(record);
+    const response = asRecord(candidate.response);
+    return Array.isArray(response?.output) ? response.output : undefined;
 };
 const getErrorMessage = (error) => {
     if (typeof error === 'string') {
@@ -301,6 +680,11 @@ const isDefinitelyUnsentWebSocketError = (error, seen = new Set()) => {
     if (!error || seen.has(error))
         return false;
     seen.add(error);
+    // The server explicitly rejects this request before model generation and
+    // instructs the client to reconnect. Retrying from durable history is safe;
+    // treating it as an ambiguous model outcome would suppress recovery.
+    if (isWebSocketConnectionLimitReachedError(error))
+        return true;
     if (typeof error === 'string') {
         const message = error.toLowerCase();
         return (message.includes('before opening') ||
@@ -319,45 +703,70 @@ const isDefinitelyUnsentWebSocketError = (error, seen = new Set()) => {
     return isDefinitelyUnsentWebSocketError(record.message, seen) || isDefinitelyUnsentWebSocketError(record.cause, seen);
 };
 const asAmbiguousModelOutcome = (error) => {
-    if (!isRetryableTransportError(error).transportFallback || isDefinitelyUnsentWebSocketError(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)) {
         return undefined;
     }
-    return new AmbiguousModelOutcomeError(getErrorMessage(error) || 'Codex request outcome is unknown.', {
-        cause: error,
-    });
+    // Incomplete stream terminals keep transportFallback=false so Codex does not
+    // force an HTTP/WS switch — but the request may already have been accepted,
+    // so replaying is unsafe. Wrap them the same way as transport-fallback
+    // failures so RetryingModel and the conversation classifier terminate.
+    if (isIncompleteStreamTerminalError(error) || isRetryableTransportError(error).transportFallback) {
+        return new AmbiguousModelOutcomeError(getErrorMessage(error) || 'Codex request outcome is unknown.', {
+            cause: error,
+        });
+    }
+    return undefined;
 };
-const hasGenerateFalse = (request) => request.modelSettings?.providerData?.generate === false;
-const withProviderData = (request, providerData) => ({
+const hasGenerateFalse = (request) => request.providerOptions?.generate === false;
+const withProviderOptions = (request, providerOptions) => ({
     ...request,
-    modelSettings: {
-        ...request.modelSettings,
-        providerData: {
-            ...request.modelSettings?.providerData,
-            ...providerData,
-        },
+    providerOptions: {
+        ...request.providerOptions,
+        ...providerOptions,
     },
 });
 export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
     modelId;
     tokenManager;
-    diagnosticLogger;
-    sessionContextService;
-    websocketReceiveTimeouts;
     codexPreviousResponseIds = new Map();
     codexConsumedToolResultCallIdsByResponseId = new Map();
+    codexFunctionCallIdsByResponseId = new Map();
     codexTurnIdsBySession = new Map();
     #serverHistoryReuseDisabled = false;
     providerTraffic;
+    diagnosticLogger;
+    sessionContextService;
+    requestCapture;
     chainedWireState = new ChainedWireState(new LunaResponsesLiteWireProtocol());
     requestTokens = new WeakMap();
-    constructor(client, modelId, tokenManager, diagnosticLogger, providerTraffic, sessionContextService, websocketReceiveTimeouts = DEFAULT_WEBSOCKET_RECEIVE_TIMEOUTS) {
-        super(client, modelId);
+    websocketReceiveTimeouts;
+    constructor(client, modelId, tokenManager, diagnosticLogger, providerTraffic, sessionContextService, websocketReceiveTimeouts = DEFAULT_WEBSOCKET_RECEIVE_TIMEOUTS, requestCapture, transport) {
+        const candidates = [
+            transport,
+            diagnosticLogger,
+            providerTraffic,
+            sessionContextService,
+            websocketReceiveTimeouts,
+            requestCapture,
+        ];
+        const injectedTransport = candidates.find((candidate) => candidate instanceof CodexResponsesTransport);
+        super(client, modelId, injectedTransport);
         this.modelId = modelId;
         this.tokenManager = tokenManager;
-        this.diagnosticLogger = diagnosticLogger;
-        this.sessionContextService = sessionContextService;
-        this.websocketReceiveTimeouts = websocketReceiveTimeouts;
-        this.providerTraffic = providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        this.diagnosticLogger = diagnosticLogger instanceof CodexResponsesTransport ? undefined : diagnosticLogger;
+        this.providerTraffic =
+            providerTraffic instanceof CodexResponsesTransport
+                ? DUMMY_PROVIDER_TRAFFIC
+                : providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        this.sessionContextService =
+            sessionContextService instanceof CodexResponsesTransport ? undefined : sessionContextService;
+        this.websocketReceiveTimeouts =
+            websocketReceiveTimeouts instanceof CodexResponsesTransport
+                ? DEFAULT_WEBSOCKET_RECEIVE_TIMEOUTS
+                : websocketReceiveTimeouts;
+        this.requestCapture = requestCapture instanceof CodexResponsesTransport ? undefined : requestCapture;
     }
     #modelNameFallback() {
         return this.modelId;
@@ -402,13 +811,39 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
         });
     }
-    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken) {
+    #logTrafficClosed(requestId, requestData, outcome, eventCount) {
+        const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
+        providerTraffic.recordResponseClosed({
+            requestId,
+            provider: 'codex',
+            model,
+            outcome,
+            eventCount,
+            modelClass: WS_RESPONSE_MODEL_CLASS,
+            modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
+        });
+    }
+    async #withTrafficLogging(responseStream, requestId, requestData, wireStateKey, wireStateToken, signal) {
         const logReceived = this.#logTrafficReceived.bind(this);
         const logFailed = this.#logTrafficFailed.bind(this);
+        const logClosed = this.#logTrafficClosed.bind(this);
         const wireState = this.chainedWireState;
         async function* wrapped() {
+            let sawTerminalEvent = false;
+            let sourceExhausted = false;
+            let streamFailed = false;
+            let eventCount = 0;
             try {
                 for await (const event of responseStream) {
+                    eventCount += 1;
+                    if (event &&
+                        typeof event === 'object' &&
+                        (event.type === 'response.completed' ||
+                            event.type === 'response.incomplete' ||
+                            event.type === 'response.failed')) {
+                        sawTerminalEvent = true;
+                    }
                     if (event &&
                         typeof event === 'object' &&
                         (event.type === 'response.completed' || event.type === 'response.incomplete') &&
@@ -421,15 +856,20 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                     }
                     yield event;
                 }
+                sourceExhausted = true;
             }
             catch (error) {
-                if (wireStateKey) {
+                streamFailed = true;
+                if (wireStateKey && !isWebSocketConnectionLimitReachedError(error)) {
                     wireState.invalidate(wireStateKey);
                 }
                 logFailed(requestId, requestData, error);
                 throw error;
             }
             finally {
+                if (!sawTerminalEvent && !sourceExhausted && !streamFailed) {
+                    logClosed(requestId, requestData, signal?.aborted ? 'aborted' : 'consumer_closed', eventCount);
+                }
                 if (wireStateKey && wireStateToken) {
                     wireState.abandon(wireStateKey, wireStateToken);
                 }
@@ -441,9 +881,9 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (!request) {
             return undefined;
         }
-        const response = await super.getResponse(request);
+        const response = await super.fetchUnaryResponse(request);
         const responseId = getResponseIdFromResponse(response);
-        this.#rememberCodexResponseId(responseId);
+        this.#rememberCodexResponseId(responseId, asRecord(response)?.output, request.input, true);
         return responseId;
     }
     async #warmupCodexStream(request) {
@@ -451,10 +891,13 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             return undefined;
         }
         let responseId;
-        for await (const event of super.getStreamedResponse(request)) {
-            responseId = getResponseIdFromStreamEvent(event) ?? 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);
+            }
         }
-        this.#rememberCodexResponseId(responseId);
         return responseId;
     }
     #prepareCodexServerHistoryRequest(request) {
@@ -468,6 +911,13 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         }
         const consumedToolResultCallIds = this.#getConsumedToolResultCallIds(previousResponseId);
         const filteredInput = filterServerManagedInput(input, consumedToolResultCallIds);
+        const knownFunctionCallIds = this.codexFunctionCallIdsByResponseId.get(previousResponseId);
+        if (request.previousResponseId === previousResponseId && knownFunctionCallIds) {
+            const orphanedCallIds = collectToolResultCallIds(filteredInput).filter((callId) => !knownFunctionCallIds.has(callId));
+            if (orphanedCallIds.length > 0) {
+                throw new OrphanedChainedToolOutputError([...new Set(orphanedCallIds)]);
+            }
+        }
         this.#warnIfConsumedToolResultsWereDropped(previousResponseId, input, filteredInput, consumedToolResultCallIds);
         if (request.previousResponseId === previousResponseId && filteredInput === input) {
             return request;
@@ -486,11 +936,18 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (!key || hasGenerateFalse(request)) {
             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) &&
-            isToolResultItem(input[input.length - 1]);
+            hasToolResultBeforeTrailingUserMessages(input);
         return isInternalToolContinuation ? this.codexPreviousResponseIds.get(key) : undefined;
     }
     #prepareCodexServerHistoryRequests(request) {
@@ -502,7 +959,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (preparedRequest.previousResponseId) {
             return { request: preparedRequest };
         }
-        const input = Array.isArray(request.input) ? dropUnpairedFunctionCalls(request.input) : request.input;
+        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 };
@@ -528,7 +985,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             }
         }
         return {
-            warmupRequest: withProviderData({
+            warmupRequest: withProviderOptions({
                 ...replayRequest,
                 input: warmupItems,
             }, { generate: false }),
@@ -547,7 +1004,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             previousResponseId,
         });
     }
-    #rememberCodexResponseId(responseId) {
+    #rememberCodexResponseId(responseId, output, input, recordChainAnchor = false) {
         if (!responseId) {
             return;
         }
@@ -556,6 +1013,9 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (key) {
             this.codexPreviousResponseIds.set(key, responseId);
         }
+        if (recordChainAnchor && (Array.isArray(output) || Array.isArray(input))) {
+            this.codexFunctionCallIdsByResponseId.set(responseId, new Set([...collectFunctionCallIds(output), ...collectFunctionCallIds(input)]));
+        }
     }
     #getConsumedToolResultCallIds(responseId) {
         if (!responseId) {
@@ -589,15 +1049,26 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             consumed.add(callId);
         }
         this.codexConsumedToolResultCallIdsByResponseId.set(responseId, consumed);
+        // A continuation may explicitly reuse the prior response ID; retain the
+        // consumed-output checkpoint under that anchor as well as the new response.
+        if (previousResponseId)
+            this.codexConsumedToolResultCallIdsByResponseId.set(previousResponseId, consumed);
     }
     #forgetCodexResponseId() {
         this.#serverHistoryReuseDisabled = true;
         this.codexPreviousResponseIds.clear();
         this.codexConsumedToolResultCallIdsByResponseId.clear();
+        this.codexFunctionCallIdsByResponseId.clear();
         this.codexTurnIdsBySession.clear();
         this.chainedWireState.clear();
     }
     #shouldForgetCodexServerHistory(error) {
+        // This rejects the new request before generation; it expires the socket,
+        // not the last acknowledged response. Retaining that response keeps an
+        // already-executed tool output paired with the call that introduced it.
+        if (isWebSocketConnectionLimitReachedError(error)) {
+            return false;
+        }
         const message = getErrorMessage(error);
         return (isPreviousResponseNotFoundError(error) ||
             message.includes('previous_response_not_found') ||
@@ -665,7 +1136,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         const { previousResponseId: _previousResponseId, ...rest } = request;
         return rest;
     }
-    async getResponse(request) {
+    async fetchUnaryResponse(request) {
         const run = async () => {
             let attemptedWithServerHistory = false;
             try {
@@ -673,9 +1144,9 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 attemptedWithServerHistory = Boolean(preparedRequest.warmupRequest || preparedRequest.request?.previousResponseId);
                 const warmupResponseId = await this.#warmupCodexUnary(preparedRequest.warmupRequest);
                 const effectiveRequest = this.#getEffectiveCodexRequestAfterWarmup(request, preparedRequest, warmupResponseId);
-                const response = await super.getResponse(effectiveRequest);
+                const response = await super.fetchUnaryResponse(effectiveRequest);
                 const responseId = getResponseIdFromResponse(response);
-                this.#rememberCodexResponseId(responseId);
+                this.#rememberCodexResponseId(responseId, asRecord(response)?.output, effectiveRequest.input);
                 this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
                 return response;
             }
@@ -686,9 +1157,9 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                         throw error;
                     }
                     const fallbackRequest = this.#withoutCodexServerHistory(request);
-                    const response = await super.getResponse(fallbackRequest);
+                    const response = await super.fetchUnaryResponse(fallbackRequest);
                     const responseId = getResponseIdFromResponse(response);
-                    this.#rememberCodexResponseId(responseId);
+                    this.#rememberCodexResponseId(responseId, asRecord(response)?.output, fallbackRequest.input);
                     this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
                     return response;
                 }
@@ -698,14 +1169,10 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
                 throw asAmbiguousModelOutcome(error) ?? error;
             }
         };
-        const currentTrace = getCurrentTrace();
-        if (currentTrace) {
-            return run();
-        }
-        return withTrace('codex-responses-ws-model-trace', run);
+        return run();
     }
-    async *getStreamedResponse(request) {
-        let yieldedAnyEvent = false;
+    async *rawStream(request) {
+        let receivedRawFrame = false;
         let attemptedWithServerHistory = false;
         try {
             const preparedRequest = this.#prepareCodexServerHistoryRequests(request);
@@ -713,38 +1180,56 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             const warmupResponseId = await this.#warmupCodexStream(preparedRequest.warmupRequest);
             const effectiveRequest = this.#getEffectiveCodexRequestAfterWarmup(request, preparedRequest, warmupResponseId);
             let responseId;
-            for await (const event of super.getStreamedResponse(effectiveRequest)) {
-                responseId = getResponseIdFromStreamEvent(event) ?? responseId;
-                this.#rememberCodexResponseId(responseId);
-                yieldedAnyEvent = true;
+            for await (const event of super.rawStream(effectiveRequest)) {
+                const eventResponseId = getResponseIdFromStreamEvent(event);
+                if (eventResponseId) {
+                    responseId = eventResponseId;
+                    this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), effectiveRequest.input);
+                }
+                if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type)) {
+                    this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
+                }
+                receivedRawFrame = true;
                 yield event;
             }
             this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
         }
         catch (error) {
-            if (isPreviousResponseUnavailableError(error) && attemptedWithServerHistory && !yieldedAnyEvent) {
+            if (isPreviousResponseUnavailableError(error) && attemptedWithServerHistory && !receivedRawFrame) {
                 this.#forgetCodexResponseId();
                 if (isPreviousResponseUnavailableError(error) && hasToolResultInput(request)) {
                     throw error;
                 }
                 const fallbackRequest = this.#withoutCodexServerHistory(request);
                 let responseId;
-                for await (const event of super.getStreamedResponse(fallbackRequest)) {
-                    responseId = getResponseIdFromStreamEvent(event) ?? responseId;
-                    this.#rememberCodexResponseId(responseId);
-                    yield event;
+                try {
+                    for await (const event of super.rawStream(fallbackRequest)) {
+                        receivedRawFrame = true;
+                        const eventResponseId = getResponseIdFromStreamEvent(event);
+                        if (eventResponseId) {
+                            responseId = eventResponseId;
+                            this.#rememberCodexResponseId(responseId, getResponseOutputFromStreamEvent(event), fallbackRequest.input);
+                        }
+                        if (TERMINAL_RESPONSE_EVENT_TYPES.has(event?.type)) {
+                            this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
+                        }
+                        yield event;
+                    }
+                    this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
+                    return;
+                }
+                catch (fallbackError) {
+                    throw asAmbiguousModelOutcome(fallbackError) ?? fallbackError;
                 }
-                this.#rememberConsumedToolResultCallIds(responseId, undefined, fallbackRequest.input);
-                return;
             }
             if (this.#shouldForgetCodexServerHistory(error)) {
                 this.#forgetCodexResponseId();
             }
-            throw (!yieldedAnyEvent ? asAmbiguousModelOutcome(error) : undefined) ?? error;
+            throw asAmbiguousModelOutcome(error) ?? error;
         }
     }
-    _buildResponsesCreateRequest(request, stream) {
-        const built = super._buildResponsesCreateRequest(request, stream);
+    buildResponsesCreateRequest(request, stream) {
+        const built = super.buildResponsesCreateRequest(request, stream);
         const requestData = normalizeCodexRequestData(built.requestData, request, this.modelId, {
             includeDeveloperInstructionsOnChainedRequest: true,
         });
@@ -760,7 +1245,7 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             requestData: prepared.requestData,
         };
     }
-    async _fetchResponse(request, stream) {
+    async fetchResponse(request, stream) {
         const requestId = randomUUID();
         const wireStateKey = RESPONSES_LITE_MODELS.has(this.modelId)
             ? this.#getCodexServerHistoryKey() ?? undefined
@@ -783,46 +1268,46 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
         if (accountId) {
             extraHeaders['chatgpt-account-id'] = accountId;
         }
+        const watchdog = createWebSocketReceiveWatchdog(request.signal, this.websocketReceiveTimeouts);
         const updatedRequest = {
             ...request,
-            signal: undefined,
-            modelSettings: {
-                ...request.modelSettings,
-                providerData: {
-                    ...request.modelSettings?.providerData,
-                    ...(codexIdentity
-                        ? {
-                            client_metadata: {
-                                ...request.modelSettings?.providerData?.client_metadata,
-                                ...codexIdentity.clientMetadata,
-                            },
-                        }
-                        : {}),
-                    ...(isResponsesLite
-                        ? {
-                            client_metadata: {
-                                ...request.modelSettings?.providerData?.client_metadata,
-                                ...(codexIdentity?.clientMetadata ?? {}),
-                                ws_request_header_x_openai_internal_codex_responses_lite: 'true',
-                            },
-                        }
-                        : {}),
-                    extraHeaders: {
-                        ...request.modelSettings?.providerData?.extraHeaders,
-                        ...extraHeaders,
-                    },
+            signal: watchdog.signal,
+            providerOptions: {
+                ...request.providerOptions,
+                ...(codexIdentity
+                    ? {
+                        client_metadata: {
+                            ...asRecord(request.providerOptions?.client_metadata),
+                            ...codexIdentity.clientMetadata,
+                        },
+                    }
+                    : {}),
+                ...(isResponsesLite
+                    ? {
+                        client_metadata: {
+                            ...asRecord(request.providerOptions?.client_metadata),
+                            ...(codexIdentity?.clientMetadata ?? {}),
+                            ws_request_header_x_openai_internal_codex_responses_lite: 'true',
+                        },
+                    }
+                    : {}),
+                extraHeaders: {
+                    ...asRecord(request.providerOptions?.extraHeaders),
+                    ...extraHeaders,
                 },
             },
         };
-        const watchdog = createWebSocketReceiveWatchdog(request.signal, this.websocketReceiveTimeouts);
-        updatedRequest.signal = watchdog.signal;
-        const builtRequest = this._buildResponsesCreateRequest(updatedRequest, true);
+        const builtRequest = this.buildResponsesCreateRequest(updatedRequest, true);
         const requestData = (asRecord(builtRequest?.requestData) ?? {});
         const wireStateToken = this.requestTokens.get(updatedRequest);
+        // This is the last application-owned point before the inherited
+        // 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);
         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)), this.diagnosticLogger);
                 if (wireStateKey && wireStateToken && typeof response?.id === 'string' && response.id.length > 0) {
                     this.chainedWireState.recordResponse(wireStateKey, wireStateToken, response.id, response.output);
                 }
@@ -832,49 +1317,73 @@ export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
             catch (error) {
                 const timeoutError = watchdog.timeoutError();
                 watchdog.close();
+                const failure = timeoutError ?? error;
                 if (wireStateKey) {
-                    this.chainedWireState.invalidate(wireStateKey);
+                    if (isWebSocketConnectionLimitReachedError(failure)) {
+                        if (wireStateToken)
+                            this.chainedWireState.abandon(wireStateKey, wireStateToken);
+                    }
+                    else {
+                        this.chainedWireState.invalidate(wireStateKey);
+                    }
                 }
-                this.#logTrafficFailed(requestId, requestData, timeoutError ?? error);
-                throw timeoutError ?? error;
+                this.#logTrafficFailed(requestId, requestData, failure);
+                throw failure;
             }
         }
         try {
-            const response = (await super._fetchResponse(updatedRequest, stream));
+            const response = (await super.fetchResponse(updatedRequest, stream));
             const patched = wrapCodexStream(watchdog.wrap(response), this.diagnosticLogger);
-            return this.#withTrafficLogging(patched, requestId, requestData, wireStateKey, wireStateToken);
+            return this.#withTrafficLogging(patched, requestId, requestData, wireStateKey, wireStateToken, updatedRequest.signal);
         }
         catch (error) {
             const timeoutError = watchdog.timeoutError();
             watchdog.close();
+            const failure = timeoutError ?? error;
             if (wireStateKey) {
-                this.chainedWireState.invalidate(wireStateKey);
+                if (isWebSocketConnectionLimitReachedError(failure)) {
+                    if (wireStateToken)
+                        this.chainedWireState.abandon(wireStateKey, wireStateToken);
+                }
+                else {
+                    this.chainedWireState.invalidate(wireStateKey);
+                }
             }
-            this.#logTrafficFailed(requestId, requestData, timeoutError ?? error);
-            throw timeoutError ?? error;
+            this.#logTrafficFailed(requestId, requestData, failure);
+            throw failure;
         }
     }
 }
 export class CodexResponsesModel extends OpenAIResponsesModel {
     modelId;
     diagnosticLogger;
-    constructor(client, modelId, diagnosticLogger) {
-        super(client, modelId);
+    requestCapture;
+    constructor(client, modelId, diagnosticLogger, requestCapture, transport) {
+        const candidates = [transport, diagnosticLogger, requestCapture];
+        const injectedTransport = candidates.find((candidate) => candidate instanceof CodexResponsesTransport);
+        super(client, modelId, injectedTransport);
         this.modelId = modelId;
-        this.diagnosticLogger = diagnosticLogger;
+        this.diagnosticLogger = diagnosticLogger instanceof CodexResponsesTransport ? undefined : diagnosticLogger;
+        this.requestCapture = requestCapture instanceof CodexResponsesTransport ? undefined : requestCapture;
     }
-    _buildResponsesCreateRequest(request, stream) {
-        const built = OpenAIResponsesModel.prototype._buildResponsesCreateRequest.call(this, request, stream);
-        return {
+    buildResponsesCreateRequest(request, stream) {
+        const built = super.buildResponsesCreateRequest(request, stream);
+        const result = {
             ...built,
             requestData: normalizeCodexRequestData(built.requestData, request, this.modelId),
         };
+        captureProviderRequest(this.requestCapture, {
+            provider: 'codex',
+            transport: 'http',
+            requestData: result.requestData,
+        });
+        return result;
     }
-    async _fetchResponse(request, stream) {
+    async fetchResponse(request, stream) {
         if (!stream) {
-            return fetchAndReconstructUnaryResponse(() => OpenAIResponsesModel.prototype._fetchResponse.call(this, request, true), this.diagnosticLogger);
+            return fetchAndReconstructUnaryResponse(() => super.fetchResponse(request, true), this.diagnosticLogger);
         }
-        const response = await OpenAIResponsesModel.prototype._fetchResponse.call(this, request, stream);
+        const response = await super.fetchResponse(request, stream);
         return wrapCodexStream(response, this.diagnosticLogger);
     }
 }
@@ -917,8 +1426,9 @@ export async function* wrapCodexStream(source, logger) {
             const item = event.item;
             const itemRecord = asRecord(item);
             // If the accumulated function_call item is missing call_id, backfill it
-            // from the itemCallIds map so the SDK's convertToOutputItem picks up the
-            // correct identifier and the continuation request sends the right call_id.
+            // from the itemCallIds map so the inherited transport's
+            // convertToOutputItem picks up the correct identifier and the continuation
+            // request sends the right call_id.
             if (itemRecord?.type === 'function_call' &&
                 !stringValue(itemRecord?.call_id) &&
                 typeof itemRecord?.id === 'string') {