@qduc/term2 0.7.3 → 0.9.0

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

@@ -1,6 +1,14 @@
-import { OpenAIResponsesModel } from '@openai/agents-openai';
-import { TimedResponsesWSModel } from './timed-responses-ws-model.js';
-import { DEFAULT_TIMED_WS_TIMEOUTS } from './timed-ws-timeouts.js';
+import { OpenAIResponsesModel, OpenAIResponsesWSModel } from '@openai/agents-openai';
+import { getCurrentTrace, withTrace } from '@openai/agents-core';
+import { randomUUID } from 'node:crypto';
+import { sanitizeHeaders } from '../utils/header-sanitizer.js';
+const DUMMY_PROVIDER_TRAFFIC = {
+    recordRequestStart() { },
+    async recordResponseReceived() { },
+    recordRequestFailed() { },
+};
+import { isPreviousResponseNotFoundError } from '../services/retry/retry-error-classification.js';
+import { computeUpstreamRetryDelayMs } from '../services/retry/upstream-retry-policy.js';
 const SUSPICIOUS_RECONSTRUCTED_OUTPUT_ITEM_COUNT = 20;
 const TERMINAL_RESPONSE_EVENT_TYPES = new Set([
     'response.completed',
@@ -8,6 +16,8 @@ const TERMINAL_RESPONSE_EVENT_TYPES = new Set([
     'response.incomplete',
     'response.error',
 ]);
+const WS_RESPONSE_MODEL_CLASS = 'OpenAIResponsesWSModel';
+const WS_RESPONSE_WRAPPER_CLASS = 'CodexResponsesWSModel';
 const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 const stringValue = (value) => (typeof value === 'string' && value ? value : undefined);
 const CODEX_REPLAY_ITEM_TYPES_WITHOUT_IDS = new Set([
@@ -93,13 +103,515 @@ const summarizeReconstructedItems = (items) => {
 // `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.
-export class CodexResponsesWSModel extends TimedResponsesWSModel {
+const CODEX_SERVER_HISTORY_TOOL_RESULT_TYPES = new Set([
+    'function_call_output',
+    'function_call_result',
+    'function_call_output_result',
+    'tool_call_output',
+    'tool_call_result',
+    'tool_call_output_item',
+    'local_shell_call_output',
+    'shell_call_output',
+    'computer_call_output',
+    'computer_call_result',
+    'apply_patch_call_output',
+]);
+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);
+    return {
+        type,
+        itemId,
+        callId,
+        isFunctionCall: type === 'function_call',
+        isToolResult: typeof type === 'string' && CODEX_SERVER_HISTORY_TOOL_RESULT_TYPES.has(type),
+    };
+};
+const isUserInputMessage = (item) => asRecord(item)?.role === 'user';
+const isToolResultItem = (item) => normalizeCodexServerHistoryItem(item).isToolResult;
+const getToolResultCallId = (item) => {
+    const normalized = normalizeCodexServerHistoryItem(item);
+    return normalized.isToolResult ? normalized.callId : undefined;
+};
+const isToolContinuationItem = (item) => {
+    const normalized = normalizeCodexServerHistoryItem(item);
+    if (normalized.isToolResult || normalized.callId) {
+        return true;
+    }
+    // Some Codex websocket function_call items arrive in reconstructed history
+    // with only their Responses item id (`fc_...`) even though their paired
+    // outputs carry the separate `call_...` invocation id. Treat those calls as
+    // part of the paired continuation region so earlier parallel outputs are not
+    // trimmed away.
+    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;
+    }
+    for (let index = input.length - 1; index >= 0; index--) {
+        if (isUserInputMessage(input[index])) {
+            return index;
+        }
+    }
+    return 0;
+};
+const filterConsumedToolResults = (items, consumedToolResultCallIds) => {
+    if (!consumedToolResultCallIds || consumedToolResultCallIds.size === 0) {
+        return items;
+    }
+    return items.filter((item) => {
+        const callId = getToolResultCallId(item);
+        return !callId || !consumedToolResultCallIds.has(callId);
+    });
+};
+const collectToolResultCallIds = (input) => {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    const ids = [];
+    for (const item of input) {
+        const callId = getToolResultCallId(item);
+        if (callId) {
+            ids.push(callId);
+        }
+    }
+    return ids;
+};
+const filterServerManagedInput = (input, consumedToolResultCallIds) => {
+    if (!Array.isArray(input)) {
+        return input;
+    }
+    if (input.length <= 1) {
+        return input.length === 1 && isToolResultItem(input[0])
+            ? filterConsumedToolResults(input, consumedToolResultCallIds)
+            : input;
+    }
+    // When previous_response_id is reused, the server already holds the
+    // previous response's output items (assistant message, reasoning, and the
+    // 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;
+        while (start > 0 && isToolContinuationItem(input[start - 1])) {
+            start--;
+        }
+        const trailing = input.slice(start);
+        // 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);
+    }
+    // Fresh user turn with no trailing tool output: the delta is the latest
+    // user message onward.
+    const deltaStart = findServerManagedDeltaStart(input);
+    return deltaStart > 0 ? input.slice(deltaStart) : input;
+};
+const getResponseIdFromResponse = (response) => {
+    const record = asRecord(response);
+    const responseId = record?.responseId ?? record?.id;
+    return typeof responseId === 'string' && responseId.length > 0 ? responseId : undefined;
+};
+const getResponseIdFromStreamEvent = (event) => {
+    const record = asRecord(event);
+    if (record?.type !== 'response_done') {
+        return undefined;
+    }
+    return getResponseIdFromResponse(record.response) ?? getResponseIdFromResponse(record);
+};
+const hasGenerateFalse = (request) => request.modelSettings?.providerData?.generate === false;
+const withProviderData = (request, providerData) => ({
+    ...request,
+    modelSettings: {
+        ...request.modelSettings,
+        providerData: {
+            ...request.modelSettings?.providerData,
+            ...providerData,
+        },
+    },
+});
+const DEFAULT_STREAM_MAX_RETRIES = 5;
+export class CodexResponsesWSModel extends OpenAIResponsesWSModel {
     tokenManager;
     diagnosticLogger;
-    constructor(client, model, tokenManager, diagnosticLogger, options = DEFAULT_TIMED_WS_TIMEOUTS) {
-        super(client, model, options);
+    sessionContextService;
+    codexPreviousResponseIds = new Map();
+    codexConsumedToolResultCallIdsByResponseId = new Map();
+    warmupSleep;
+    warmupRandom;
+    #serverHistoryReuseDisabled = false;
+    providerTraffic;
+    constructor(client, model, tokenManager, diagnosticLogger, providerTraffic, sessionContextService, warmupRetryDependencies) {
+        super(client, model);
         this.tokenManager = tokenManager;
         this.diagnosticLogger = diagnosticLogger;
+        this.sessionContextService = sessionContextService;
+        this.warmupSleep =
+            warmupRetryDependencies?.sleep ??
+                ((delayMs) => new Promise((resolve) => {
+                    setTimeout(resolve, delayMs);
+                }));
+        this.warmupRandom = warmupRetryDependencies?.random ?? Math.random;
+        this.providerTraffic = providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+    }
+    #modelNameFallback() {
+        return this.model ?? 'unknown';
+    }
+    #logTrafficStarted(requestId, requestData, headers) {
+        const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
+        const sanitizedHeaders = headers ? sanitizeHeaders(headers) : undefined;
+        providerTraffic.recordRequestStart({
+            requestId,
+            provider: 'codex',
+            model,
+            sentBody: requestData,
+            headers: sanitizedHeaders,
+            modelClass: WS_RESPONSE_MODEL_CLASS,
+            modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
+        });
+    }
+    #logTrafficReceived(requestId, requestData, response) {
+        const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
+        providerTraffic.recordResponseReceived({
+            requestId,
+            provider: 'codex',
+            model,
+            status: 200,
+            response: response,
+            transport: 'websocket',
+            modelClass: WS_RESPONSE_MODEL_CLASS,
+            modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
+        });
+    }
+    #logTrafficFailed(requestId, requestData, error) {
+        const providerTraffic = this.providerTraffic ?? DUMMY_PROVIDER_TRAFFIC;
+        const model = typeof requestData.model === 'string' ? requestData.model : this.#modelNameFallback();
+        providerTraffic.recordRequestFailed({
+            requestId,
+            provider: 'codex',
+            model,
+            error,
+            modelClass: WS_RESPONSE_MODEL_CLASS,
+            modelWrapperClass: WS_RESPONSE_WRAPPER_CLASS,
+        });
+    }
+    async #withTrafficLogging(responseStream, requestId, requestData) {
+        const logReceived = this.#logTrafficReceived.bind(this);
+        const logFailed = this.#logTrafficFailed.bind(this);
+        async function* wrapped() {
+            try {
+                for await (const event of responseStream) {
+                    if (event &&
+                        typeof event === 'object' &&
+                        (event.type === 'response.completed' || event.type === 'response.incomplete') &&
+                        event.response) {
+                        const response = event.response;
+                        logReceived(requestId, requestData, response);
+                    }
+                    yield event;
+                }
+            }
+            catch (error) {
+                logFailed(requestId, requestData, error);
+                throw error;
+            }
+        }
+        return wrapped();
+    }
+    async #shouldRetryCodexWarmup(request, error, kind, attempt) {
+        const retryAdvice = typeof this.getRetryAdvice === 'function'
+            ? await this.getRetryAdvice({ request, error, stream: kind === 'stream', attempt })
+            : undefined;
+        return retryAdvice?.suggested === true && retryAdvice?.replaySafety === 'safe';
+    }
+    async #sleepBeforeCodexWarmupRetry(attempt) {
+        const delayMs = computeUpstreamRetryDelayMs({ attemptNumber: attempt, random: this.warmupRandom });
+        await this.warmupSleep(delayMs);
+    }
+    async #warmupCodexUnary(request) {
+        if (!request) {
+            return undefined;
+        }
+        const maxAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+        let attempt = 1;
+        while (attempt <= maxAttempts) {
+            try {
+                const response = await super.getResponse(request);
+                const responseId = getResponseIdFromResponse(response);
+                this.#rememberCodexResponseId(responseId);
+                return responseId;
+            }
+            catch (error) {
+                const canSafelyRetry = await this.#shouldRetryCodexWarmup(request, error, 'unary', attempt);
+                if (!canSafelyRetry) {
+                    throw error;
+                }
+                if (attempt >= maxAttempts) {
+                    return undefined;
+                }
+                await this.#sleepBeforeCodexWarmupRetry(attempt);
+                attempt++;
+            }
+        }
+        return undefined;
+    }
+    async #warmupCodexStream(request) {
+        if (!request) {
+            return undefined;
+        }
+        const maxAttempts = DEFAULT_STREAM_MAX_RETRIES + 1;
+        let attempt = 1;
+        while (attempt <= maxAttempts) {
+            try {
+                let responseId;
+                for await (const event of super.getStreamedResponse(request)) {
+                    responseId = getResponseIdFromStreamEvent(event) ?? responseId;
+                }
+                this.#rememberCodexResponseId(responseId);
+                return responseId;
+            }
+            catch (error) {
+                const canSafelyRetry = await this.#shouldRetryCodexWarmup(request, error, 'stream', attempt);
+                if (!canSafelyRetry) {
+                    throw error;
+                }
+                if (attempt >= maxAttempts) {
+                    return undefined;
+                }
+                await this.#sleepBeforeCodexWarmupRetry(attempt);
+                attempt++;
+            }
+        }
+        return undefined;
+    }
+    #prepareCodexServerHistoryRequest(request) {
+        const explicitPreviousResponseId = typeof request.previousResponseId === 'string' && request.previousResponseId.length > 0
+            ? request.previousResponseId
+            : undefined;
+        const input = request.input;
+        const previousResponseId = explicitPreviousResponseId ?? this.#getRememberedCodexResponseIdForRequest(request);
+        if (!previousResponseId) {
+            return request;
+        }
+        const consumedToolResultCallIds = this.#getConsumedToolResultCallIds(previousResponseId);
+        const filteredInput = filterServerManagedInput(input, consumedToolResultCallIds);
+        this.#warnIfConsumedToolResultsWereDropped(previousResponseId, input, filteredInput, consumedToolResultCallIds);
+        if (request.previousResponseId === previousResponseId && filteredInput === input) {
+            return request;
+        }
+        return {
+            ...request,
+            previousResponseId,
+            input: filteredInput,
+        };
+    }
+    #getRememberedCodexResponseIdForRequest(request) {
+        if (this.#serverHistoryReuseDisabled) {
+            return undefined;
+        }
+        const key = this.#getCodexServerHistoryKey();
+        if (!key || hasGenerateFalse(request)) {
+            return undefined;
+        }
+        const input = request.input;
+        const isInternalToolContinuation = Array.isArray(input) &&
+            input.length > 1 &&
+            input.some(isUserInputMessage) &&
+            isToolResultItem(input[input.length - 1]);
+        return isInternalToolContinuation ? this.codexPreviousResponseIds.get(key) : undefined;
+    }
+    #prepareCodexServerHistoryRequests(request) {
+        const key = this.#getCodexServerHistoryKey();
+        if (!key || hasGenerateFalse(request)) {
+            return { request };
+        }
+        const preparedRequest = this.#prepareCodexServerHistoryRequest(request);
+        if (preparedRequest.previousResponseId) {
+            return { request: preparedRequest };
+        }
+        const input = request.input;
+        if (!Array.isArray(input) || input.length === 0) {
+            return { request };
+        }
+        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: withProviderData({
+                ...request,
+                input: warmupItems,
+            }, { generate: false }),
+            request: {
+                ...request,
+                input: deltaInput,
+            },
+        };
+    }
+    #withCodexPreviousResponseId(request, previousResponseId) {
+        if (!previousResponseId) {
+            return request;
+        }
+        return this.#prepareCodexServerHistoryRequest({
+            ...request,
+            previousResponseId,
+        });
+    }
+    #rememberCodexResponseId(responseId) {
+        if (!responseId) {
+            return;
+        }
+        this.#serverHistoryReuseDisabled = false;
+        const key = this.#getCodexServerHistoryKey();
+        if (key) {
+            this.codexPreviousResponseIds.set(key, responseId);
+        }
+    }
+    #getConsumedToolResultCallIds(responseId) {
+        if (!responseId) {
+            return undefined;
+        }
+        return this.codexConsumedToolResultCallIdsByResponseId.get(responseId);
+    }
+    #warnIfConsumedToolResultsWereDropped(previousResponseId, input, filteredInput, consumedToolResultCallIds) {
+        if (!consumedToolResultCallIds || consumedToolResultCallIds.size === 0 || filteredInput === input) {
+            return;
+        }
+        const filteredCallIds = new Set(collectToolResultCallIds(filteredInput));
+        const droppedCallIds = collectToolResultCallIds(input).filter((callId) => consumedToolResultCallIds.has(callId) && !filteredCallIds.has(callId));
+        if (droppedCallIds.length === 0) {
+            return;
+        }
+        this.diagnosticLogger?.warn?.('Codex provider dropped already-consumed tool outputs before continuation', {
+            eventType: 'codex.tool_outputs.dropped_consumed',
+            category: 'provider',
+            phase: 'request_prepare',
+            previousResponseId,
+            droppedCallIds,
+        });
+    }
+    #rememberConsumedToolResultCallIds(responseId, previousResponseId, input) {
+        if (!responseId) {
+            return;
+        }
+        const consumed = new Set(this.#getConsumedToolResultCallIds(previousResponseId));
+        for (const callId of collectToolResultCallIds(input)) {
+            consumed.add(callId);
+        }
+        this.codexConsumedToolResultCallIdsByResponseId.set(responseId, consumed);
+    }
+    #forgetCodexResponseId() {
+        this.#serverHistoryReuseDisabled = true;
+        this.codexPreviousResponseIds.clear();
+        this.codexConsumedToolResultCallIdsByResponseId.clear();
+    }
+    #getCodexServerHistoryKey() {
+        const trafficContext = this.sessionContextService?.getContext() ?? null;
+        return trafficContext?.sessionId ?? trafficContext?.traceId ?? null;
+    }
+    #getEffectiveCodexRequestAfterWarmup(originalRequest, preparedRequest, warmupResponseId) {
+        if (!preparedRequest.warmupRequest) {
+            return preparedRequest.request;
+        }
+        return warmupResponseId
+            ? this.#withCodexPreviousResponseId(preparedRequest.request, warmupResponseId)
+            : originalRequest;
+    }
+    async getResponse(request) {
+        const run = async () => {
+            try {
+                const preparedRequest = this.#prepareCodexServerHistoryRequests(request);
+                const warmupResponseId = await this.#warmupCodexUnary(preparedRequest.warmupRequest);
+                const effectiveRequest = this.#getEffectiveCodexRequestAfterWarmup(request, preparedRequest, warmupResponseId);
+                const response = await super.getResponse(effectiveRequest);
+                const responseId = getResponseIdFromResponse(response);
+                this.#rememberCodexResponseId(responseId);
+                this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
+                return response;
+            }
+            catch (error) {
+                const message = typeof error === 'string'
+                    ? error
+                    : error && typeof error === 'object' && 'message' in error
+                        ? String(error.message ?? '')
+                        : '';
+                if (isPreviousResponseNotFoundError(error) || message.includes('previous_response_not_found')) {
+                    this.#forgetCodexResponseId();
+                }
+                throw error;
+            }
+        };
+        const currentTrace = getCurrentTrace();
+        if (currentTrace) {
+            return run();
+        }
+        return withTrace('codex-responses-ws-model-trace', run);
+    }
+    async *getStreamedResponse(request) {
+        try {
+            const preparedRequest = this.#prepareCodexServerHistoryRequests(request);
+            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);
+                yield event;
+            }
+            this.#rememberConsumedToolResultCallIds(responseId, effectiveRequest.previousResponseId, effectiveRequest.input);
+        }
+        catch (error) {
+            const message = typeof error === 'string'
+                ? error
+                : error && typeof error === 'object' && 'message' in error
+                    ? String(error.message ?? '')
+                    : '';
+            if (isPreviousResponseNotFoundError(error) || message.includes('previous_response_not_found')) {
+                this.#forgetCodexResponseId();
+            }
+            throw error;
+        }
     }
     _buildResponsesCreateRequest(request, stream) {
         const built = super._buildResponsesCreateRequest(request, stream);
@@ -109,6 +621,9 @@ export class CodexResponsesWSModel extends TimedResponsesWSModel {
         };
     }
     async _fetchResponse(request, stream) {
+        const requestId = randomUUID();
+        const builtRequest = this._buildResponsesCreateRequest(request, true);
+        const requestData = (asRecord(builtRequest?.requestData) ?? {});
         const accessToken = await this.tokenManager.getOrRefreshAccessToken();
         const accountId = this.tokenManager.getAccountId();
         const extraHeaders = {
@@ -118,6 +633,7 @@ export class CodexResponsesWSModel extends TimedResponsesWSModel {
         if (accountId) {
             extraHeaders['chatgpt-account-id'] = accountId;
         }
+        this.#logTrafficStarted(requestId, requestData, extraHeaders);
         const updatedRequest = {
             ...request,
             modelSettings: {
@@ -132,10 +648,25 @@ export class CodexResponsesWSModel extends TimedResponsesWSModel {
             },
         };
         if (!stream) {
-            return fetchAndReconstructUnaryResponse(() => super._fetchResponse(updatedRequest, true), this.diagnosticLogger);
+            try {
+                const response = await fetchAndReconstructUnaryResponse(() => super._fetchResponse(updatedRequest, true), this.diagnosticLogger);
+                this.#logTrafficReceived(requestId, requestData, response);
+                return response;
+            }
+            catch (error) {
+                this.#logTrafficFailed(requestId, requestData, error);
+                throw error;
+            }
+        }
+        try {
+            const response = (await super._fetchResponse(updatedRequest, stream));
+            const patched = wrapCodexStream(response, this.diagnosticLogger);
+            return this.#withTrafficLogging(patched, requestId, requestData);
+        }
+        catch (error) {
+            this.#logTrafficFailed(requestId, requestData, error);
+            throw error;
         }
-        const response = await super._fetchResponse(updatedRequest, stream);
-        return wrapCodexStream(response, this.diagnosticLogger);
     }
 }
 export class CodexResponsesModel extends OpenAIResponsesModel {
@@ -174,20 +705,46 @@ async function fetchAndReconstructUnaryResponse(fetchStream, logger) {
 }
 export async function* wrapCodexStream(source, logger) {
     let accumulatedItems = [];
+    // Track call_id values from function_call_arguments events keyed by item_id,
+    // since the Codex server may omit call_id on output_item.done for function_calls
+    // while still expecting it on continuation requests.
+    const itemCallIds = new Map();
     for await (let event of source) {
         const type = event?.type;
-        if (type === 'response.error' && event.error) {
-            const errMsg = event.error.message || JSON.stringify(event.error);
+        if (type === 'response.error') {
+            const errMsg = event.error?.message || JSON.stringify(event.error ?? event);
             logger?.error?.('Codex stream received response.error event', {
                 eventType: 'codex.response.stream_error_event',
-                error: event.error,
+                error: event.error ?? event,
             });
             throw new Error(`Codex provider stream error: ${errMsg}`);
         }
+        if (type === 'response.function_call_arguments.done' &&
+            typeof event.call_id === 'string' &&
+            typeof event.item_id === 'string') {
+            // Capture the authoritative call_id from the arguments-done event.
+            itemCallIds.set(event.item_id, event.call_id);
+        }
         if (type === 'response.output_item.done' && event.item) {
+            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.
+            if (itemRecord?.type === 'function_call' &&
+                !stringValue(itemRecord?.call_id) &&
+                typeof itemRecord?.id === 'string') {
+                const knownCallId = itemCallIds.get(itemRecord.id);
+                if (knownCallId) {
+                    // Clone the item with the backfilled call_id.
+                    event = { ...event, item: { ...itemRecord, call_id: knownCallId } };
+                }
+            }
             accumulatedItems.push(event.item);
         }
         else if (TERMINAL_RESPONSE_EVENT_TYPES.has(type) && event.response) {
+            // Clear the per-turn map on terminal events so we don't leak IDs across responses.
+            itemCallIds.clear();
             const output = event.response.output;
             const isMissingOrEmptyOutput = output === undefined || (Array.isArray(output) && output.length === 0);
             if (isMissingOrEmptyOutput && accumulatedItems.length > 0) {