@qduc/term2 0.7.2 → 0.8.0

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

@@ -1,9 +1,7 @@
-import test from 'ava';
+import { it, expect } from 'vitest';
 import { withTrace } from '@openai/agents-core';
-import { OpenAIResponsesModel } from '@openai/agents-openai';
+import { OpenAIResponsesModel, OpenAIResponsesWSModel } from '@openai/agents-openai';
 import { CodexResponsesModel, CodexResponsesWSModel, wrapCodexStream } from './codex-responses-model.js';
-import { TimedResponsesWSModel } from './timed-responses-ws-model.js';
-import { DEFAULT_TIMED_WS_TIMEOUTS } from './timed-ws-timeouts.js';
 // Fixture mirrors the SSE shape that codex's responses endpoint emits: deltas
 // and output_item.done carry the assistant message, but the terminal
 // response.completed frame ships an empty `output` array. The wrapper has to
@@ -22,7 +20,7 @@ async function collect(iter) {
         out.push(ev);
     return out;
 }
-test('wrapCodexStream reconstructs response.completed.output from streamed output_item.done items', async (t) => {
+it('wrapCodexStream reconstructs response.completed.output from streamed output_item.done items', async () => {
     const item = {
         type: 'message',
         id: 'msg_1',
@@ -46,11 +44,11 @@ test('wrapCodexStream reconstructs response.completed.output from streamed outpu
         },
     ])));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.truthy(completed);
-    t.is(completed.response.output.length, 1);
-    t.is(completed.response.output[0], item);
+    expect(completed).toBeTruthy();
+    expect(completed.response.output.length).toBe(1);
+    expect(completed.response.output[0]).toBe(item);
 });
-test('wrapCodexStream reconstructs missing terminal response.output from streamed output_item.done items', async (t) => {
+it('wrapCodexStream reconstructs missing terminal response.output from streamed output_item.done items', async () => {
     const item = {
         type: 'message',
         id: 'msg_missing_output',
@@ -69,10 +67,10 @@ test('wrapCodexStream reconstructs missing terminal response.output from streame
         },
     ])));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.truthy(completed);
-    t.deepEqual(completed.response.output, [item]);
+    expect(completed).toBeTruthy();
+    expect(completed.response.output).toEqual([item]);
 });
-test('wrapCodexStream reconstructs missing output for non-completed terminal frames', async (t) => {
+it('wrapCodexStream reconstructs missing output for non-completed terminal frames', async () => {
     const item = {
         type: 'message',
         id: 'msg_incomplete',
@@ -91,10 +89,10 @@ test('wrapCodexStream reconstructs missing output for non-completed terminal fra
         },
     ])));
     const incomplete = events.find((e) => e.type === 'response.incomplete');
-    t.truthy(incomplete);
-    t.deepEqual(incomplete.response.output, [item]);
+    expect(incomplete).toBeTruthy();
+    expect(incomplete.response.output).toEqual([item]);
 });
-test('wrapCodexStream leaves non-empty output untouched', async (t) => {
+it('wrapCodexStream leaves non-empty output untouched', async () => {
     const serverItem = { type: 'message', id: 'msg_real' };
     const streamedItem = { type: 'message', id: 'msg_accum' };
     const events = await collect(wrapCodexStream(makeStream([
@@ -105,10 +103,10 @@ test('wrapCodexStream leaves non-empty output untouched', async (t) => {
         },
     ])));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.is(completed.response.output.length, 1);
-    t.is(completed.response.output[0], serverItem);
+    expect(completed.response.output.length).toBe(1);
+    expect(completed.response.output[0]).toBe(serverItem);
 });
-test('wrapCodexStream reconstructs each completed response from only its own streamed items', async (t) => {
+it('wrapCodexStream reconstructs each completed response from only its own streamed items', async () => {
     const firstItem = { type: 'function_call', id: 'fc_1', call_id: 'call_1' };
     const secondItem = { type: 'message', id: 'msg_2', role: 'assistant' };
     const events = await collect(wrapCodexStream(makeStream([
@@ -120,11 +118,11 @@ test('wrapCodexStream reconstructs each completed response from only its own str
         { type: 'response.completed', response: { id: 'resp_2', output: [], usage: {} } },
     ])));
     const completed = events.filter((e) => e.type === 'response.completed');
-    t.is(completed.length, 2);
-    t.deepEqual(completed[0].response.output, [firstItem]);
-    t.deepEqual(completed[1].response.output, [secondItem]);
+    expect(completed.length).toBe(2);
+    expect(completed[0].response.output).toEqual([firstItem]);
+    expect(completed[1].response.output).toEqual([secondItem]);
 });
-test('wrapCodexStream keeps empty output empty when no items were streamed', async (t) => {
+it('wrapCodexStream keeps empty output empty when no items were streamed', async () => {
     const events = await collect(wrapCodexStream(makeStream([
         {
             type: 'response.completed',
@@ -132,9 +130,45 @@ test('wrapCodexStream keeps empty output empty when no items were streamed', asy
         },
     ])));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.is(completed.response.output.length, 0);
+    expect(completed.response.output.length).toBe(0);
 });
-test('wrapCodexStream survives a frozen response object by cloning', async (t) => {
+it('wrapCodexStream backfills function_call call_id from function_call_arguments.done event', async () => {
+    const expectedCallId = 'call_backfilled';
+    // Simulate Codex sending function_call_arguments.done with the call_id
+    // followed by output_item.done WITHOUT a call_id field.
+    const item = {
+        type: 'function_call',
+        id: 'fc_backfill',
+        name: 'shell',
+        arguments: '{}',
+        status: 'completed',
+        // NO call_id — Codex sometimes omits it here
+    };
+    const events = await collect(wrapCodexStream(makeStream([
+        {
+            type: 'response.function_call_arguments.done',
+            item_id: 'fc_backfill',
+            call_id: expectedCallId,
+            name: 'shell',
+            arguments: '{}',
+        },
+        { type: 'response.output_item.done', output_index: 0, item },
+        {
+            type: 'response.completed',
+            response: {
+                id: 'resp_backfill',
+                output: [],
+                usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+            },
+        },
+    ])));
+    const completed = events.find((e) => e.type === 'response.completed');
+    expect(completed).toBeTruthy();
+    expect(completed.response.output.length).toBe(1);
+    expect(completed.response.output[0].call_id).toBe(expectedCallId);
+    expect(completed.response.output[0].id).toBe('fc_backfill');
+});
+it('wrapCodexStream survives a frozen response object by cloning', async () => {
     const item = { type: 'message', id: 'msg_frozen' };
     const frozenResponse = Object.freeze({ id: 'resp_f', output: [], usage: {} });
     const events = await collect(wrapCodexStream(makeStream([
@@ -142,10 +176,10 @@ test('wrapCodexStream survives a frozen response object by cloning', async (t) =
         { type: 'response.completed', response: frozenResponse },
     ])));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.is(completed.response.output.length, 1);
-    t.is(completed.response.output[0], item);
+    expect(completed.response.output.length).toBe(1);
+    expect(completed.response.output[0]).toBe(item);
 });
-test('wrapCodexStream warns with metadata when reconstructed output is suspiciously large', async (t) => {
+it('wrapCodexStream warns with metadata when reconstructed output is suspiciously large', async () => {
     const warnings = [];
     const items = Array.from({ length: 21 }, (_, index) => ({
         type: index % 2 === 0 ? 'function_call' : 'function_call_output',
@@ -158,14 +192,14 @@ test('wrapCodexStream warns with metadata when reconstructed output is suspiciou
         { type: 'response.completed', response: { id: 'resp_large', output: [], usage: {} } },
     ]), { warn: (_message, meta) => warnings.push(meta) }));
     const completed = events.find((e) => e.type === 'response.completed');
-    t.is(completed.response.output.length, 21);
-    t.is(warnings.length, 1);
-    t.is(warnings[0].eventType, 'codex.reconstructed_output.suspicious');
-    t.is(warnings[0].responseId, 'resp_large');
-    t.is(warnings[0].itemCount, 21);
-    t.is(warnings[0].firstItemId, 'item_0');
-    t.is(warnings[0].lastItemId, 'item_20');
-    t.false('output' in warnings[0]);
+    expect(completed.response.output.length).toBe(21);
+    expect(warnings.length).toBe(1);
+    expect(warnings[0].eventType).toBe('codex.reconstructed_output.suspicious');
+    expect(warnings[0].responseId).toBe('resp_large');
+    expect(warnings[0].itemCount).toBe(21);
+    expect(warnings[0].firstItemId).toBe('item_0');
+    expect(warnings[0].lastItemId).toBe('item_20');
+    expect('output' in warnings[0]).toBe(false);
 });
 // Integration check: confirm CodexResponsesModel.getStreamedResponse threads
 // the stream through wrapCodexStream so a Codex-style terminal frame with
@@ -173,7 +207,7 @@ test('wrapCodexStream warns with metadata when reconstructed output is suspiciou
 // parent's `_fetchResponse` on the prototype so our subclass override (which
 // delegates to super) sees a controlled stream without needing a real OpenAI
 // client.
-test.serial('CodexResponsesModel.getStreamedResponse yields response_done with reconstructed output', async (t) => {
+it.sequential('CodexResponsesModel.getStreamedResponse yields response_done with reconstructed output', async () => {
     const original = OpenAIResponsesModel.prototype._fetchResponse;
     OpenAIResponsesModel.prototype._fetchResponse = async function () {
         return makeStream([
@@ -204,17 +238,17 @@ test.serial('CodexResponsesModel.getStreamedResponse yields response_done with r
         const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
         const events = await collect(model.getStreamedResponse(request));
         const done = events.find((e) => e.type === 'response_done');
-        t.truthy(done, 'expected a response_done event');
-        t.is(done.response.output.length, 1);
-        t.is(done.response.output[0].type, 'message');
-        t.is(done.response.output[0].id, 'msg_1');
-        t.is(done.response.output[0].role, 'assistant');
+        expect(done).toBeTruthy();
+        expect(done.response.output.length).toBe(1);
+        expect(done.response.output[0].type).toBe('message');
+        expect(done.response.output[0].id).toBe('msg_1');
+        expect(done.response.output[0].role).toBe('assistant');
     }
     finally {
         OpenAIResponsesModel.prototype._fetchResponse = original;
     }
 });
-test.serial('CodexResponsesModel.getStreamedResponse tolerates missing terminal response.output', async (t) => {
+it.sequential('CodexResponsesModel.getStreamedResponse tolerates missing terminal response.output', async () => {
     const original = OpenAIResponsesModel.prototype._fetchResponse;
     OpenAIResponsesModel.prototype._fetchResponse = async function () {
         return makeStream([
@@ -244,15 +278,15 @@ test.serial('CodexResponsesModel.getStreamedResponse tolerates missing terminal
         const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
         const events = await collect(model.getStreamedResponse(request));
         const done = events.find((e) => e.type === 'response_done');
-        t.truthy(done, 'expected a response_done event');
-        t.is(done.response.output.length, 1);
-        t.is(done.response.output[0].id, 'msg_missing_output');
+        expect(done).toBeTruthy();
+        expect(done.response.output.length).toBe(1);
+        expect(done.response.output[0].id).toBe('msg_missing_output');
     }
     finally {
         OpenAIResponsesModel.prototype._fetchResponse = original;
     }
 });
-test.serial('CodexResponsesModel._buildResponsesCreateRequest merges modelSettings.include into requestData.include', (t) => {
+it.sequential('CodexResponsesModel._buildResponsesCreateRequest merges modelSettings.include into requestData.include', () => {
     const original = OpenAIResponsesModel.prototype._buildResponsesCreateRequest;
     OpenAIResponsesModel.prototype._buildResponsesCreateRequest = function () {
         return {
@@ -270,13 +304,13 @@ test.serial('CodexResponsesModel._buildResponsesCreateRequest merges modelSettin
                 include: ['reasoning.encrypted_content', 'file_search_call.results'],
             },
         }, true);
-        t.deepEqual(built.requestData.include, ['file_search_call.results', 'reasoning.encrypted_content']);
+        expect(built.requestData.include).toEqual(['file_search_call.results', 'reasoning.encrypted_content']);
     }
     finally {
         OpenAIResponsesModel.prototype._buildResponsesCreateRequest = original;
     }
 });
-test.serial('CodexResponsesModel._buildResponsesCreateRequest strips temperature from requestData', (t) => {
+it.sequential('CodexResponsesModel._buildResponsesCreateRequest strips temperature from requestData', () => {
     const original = OpenAIResponsesModel.prototype._buildResponsesCreateRequest;
     OpenAIResponsesModel.prototype._buildResponsesCreateRequest = function () {
         return {
@@ -290,13 +324,13 @@ test.serial('CodexResponsesModel._buildResponsesCreateRequest strips temperature
     try {
         const model = new CodexResponsesModel({}, 'gpt-5-codex');
         const built = model._buildResponsesCreateRequest({ modelSettings: { temperature: 0.2 } }, true);
-        t.false('temperature' in built.requestData);
+        expect('temperature' in built.requestData).toBe(false);
     }
     finally {
         OpenAIResponsesModel.prototype._buildResponsesCreateRequest = original;
     }
 });
-test.serial('CodexResponsesModel._buildResponsesCreateRequest forwards prompt_cache_key from modelSettings', (t) => {
+it.sequential('CodexResponsesModel._buildResponsesCreateRequest forwards prompt_cache_key from modelSettings', () => {
     const original = OpenAIResponsesModel.prototype._buildResponsesCreateRequest;
     OpenAIResponsesModel.prototype._buildResponsesCreateRequest = function () {
         return {
@@ -315,14 +349,45 @@ test.serial('CodexResponsesModel._buildResponsesCreateRequest forwards prompt_ca
                 prompt_cache_key: 'conv_123',
             },
         }, true);
-        t.is(built.requestData.prompt_cache_key, 'conv_123');
-        t.false('temperature' in built.requestData);
+        expect(built.requestData.prompt_cache_key).toBe('conv_123');
+        expect('temperature' in built.requestData).toBe(false);
     }
     finally {
         OpenAIResponsesModel.prototype._buildResponsesCreateRequest = original;
     }
 });
-test('CodexResponsesWSModel extends TimedResponsesWSModel and configures timeouts', (t) => {
+it.sequential('CodexResponsesModel._buildResponsesCreateRequest strips replay item ids from input', () => {
+    const original = OpenAIResponsesModel.prototype._buildResponsesCreateRequest;
+    OpenAIResponsesModel.prototype._buildResponsesCreateRequest = function () {
+        return {
+            requestData: {
+                input: [
+                    { id: 'msg_1', type: 'message', role: 'assistant', content: [] },
+                    { id: 'rs_1', type: 'reasoning', summary: [], encrypted_content: 'enc' },
+                    { id: 'fc_1', type: 'function_call', call_id: 'call_1', name: 'shell', arguments: '{}' },
+                    { type: 'function_call_output', call_id: 'call_1', output: 'ok' },
+                    { id: 'ig_1', type: 'image_generation_call', status: 'completed', result: 'image' },
+                ],
+            },
+            sdkRequestHeaders: {},
+            signal: undefined,
+        };
+    };
+    try {
+        const model = new CodexResponsesModel({}, 'gpt-5-codex');
+        const built = model._buildResponsesCreateRequest({ modelSettings: {} }, true);
+        expect('id' in built.requestData.input[0]).toBe(false);
+        expect('id' in built.requestData.input[1]).toBe(false);
+        expect('id' in built.requestData.input[2]).toBe(false);
+        expect(built.requestData.input[2].call_id).toBe('call_1');
+        expect('id' in built.requestData.input[3]).toBe(false);
+        expect(built.requestData.input[4].id).toBe('ig_1');
+    }
+    finally {
+        OpenAIResponsesModel.prototype._buildResponsesCreateRequest = original;
+    }
+});
+it('CodexResponsesWSModel extends OpenAIResponsesWSModel', () => {
     const mockClient = {
         baseURL: 'https://api.openai.com',
         apiKey: 'test-key',
@@ -332,28 +397,161 @@ test('CodexResponsesWSModel extends TimedResponsesWSModel and configures timeout
         getOrRefreshAccessToken: async () => 'token',
         getAccountId: () => 'acc_123',
     };
-    const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, {
-        connectTimeoutMs: 1000,
-        idleTimeoutMs: 5000,
-    });
-    t.deepEqual(model.options, { connectTimeoutMs: 1000, idleTimeoutMs: 5000 });
+    const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager);
+    expect(model instanceof OpenAIResponsesWSModel).toBe(true);
 });
-test('CodexResponsesWSModel uses default timeouts when none are passed', (t) => {
-    const mockClient = {
-        baseURL: 'https://api.openai.com',
-        apiKey: 'test-key',
-        _options: {},
+it.sequential('CodexResponsesWSModel emits traffic logs for websocket streamed responses', async () => {
+    const original = OpenAIResponsesWSModel.prototype._fetchResponse;
+    const logs = [];
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function () {
+        return makeStream([
+            { type: 'response.created', response: { id: 'resp_ws_traffic' } },
+            {
+                type: 'response.output_item.done',
+                output_index: 0,
+                item: {
+                    type: 'message',
+                    id: 'msg_ws_traffic',
+                    role: 'assistant',
+                    status: 'completed',
+                    content: [{ type: 'output_text', text: 'Hello WS traffic!' }],
+                },
+            },
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp_ws_traffic',
+                    output: [],
+                    usage: { input_tokens: 3, output_tokens: 4, total_tokens: 7 },
+                },
+            },
+        ]);
+    };
+    const loggingService = {
+        debug: (message, meta) => logs.push({ level: 'debug', message, meta }),
+        error: (message, meta) => logs.push({ level: 'error', message, meta }),
+        getCorrelationId: () => 'trace-log-1',
+    };
+    const sessionContextService = {
+        getContext: () => ({
+            sessionId: 'sess_ws_1',
+            sessionStartedAt: '2025-01-01T00:00:00.000Z',
+            firstUserMessagePreview: 'hello ws',
+            mode: 'websocket',
+            traceId: 'trace-session-1',
+        }),
+        runWithContext: (_context, fn) => fn(),
     };
     const tokenManager = {
         getOrRefreshAccessToken: async () => 'token',
         getAccountId: () => 'acc_123',
     };
-    const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager);
-    t.deepEqual(model.options, {
-        ...DEFAULT_TIMED_WS_TIMEOUTS,
-    });
+    try {
+        const model = new CodexResponsesWSModel({ baseURL: 'https://api.openai.com', apiKey: 'test-key', _options: {} }, 'gpt-5-codex', tokenManager, undefined, loggingService, sessionContextService);
+        const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
+        const events = await collect(model.getStreamedResponse(request));
+        expect(events[events.length - 1].event?.type).toBe('response.completed');
+        expect(logs.length).toBe(2);
+        expect(logs[0].meta.eventType).toBe('provider.request.started');
+        expect(logs[1].meta.eventType).toBe('provider.response.received');
+        expect(logs[0].meta.requestId).toBe(logs[1].meta.requestId);
+        expect(logs[0].meta.sessionId).toBe('sess_ws_1');
+        expect(logs[0].meta.headers.authorization).toBe('[REDACTED]');
+        expect(logs[1].meta.payload.transport).toBe('websocket');
+        expect(logs[1].meta.payload.responseId).toBe('resp_ws_traffic');
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = original;
+    }
 });
-test.serial('CodexResponsesModel.getResponse (unary) intercepts and runs as stream under the hood', async (t) => {
+it.sequential('CodexResponsesWSModel logs reasoning and tool calls in choice payload matching HTTP/SSE logs', async () => {
+    const logs = [];
+    const original = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function () {
+        return makeStream([
+            { type: 'response.created', response: { id: 'resp_ws_reasoning_tool' } },
+            {
+                type: 'response.output_item.done',
+                output_index: 0,
+                item: {
+                    type: 'reasoning',
+                    id: 'rs_123',
+                    text: 'Let me think about this request.',
+                    summary: [],
+                },
+            },
+            {
+                type: 'response.output_item.done',
+                output_index: 1,
+                item: {
+                    type: 'function_call',
+                    id: 'fc_123',
+                    call_id: 'call_123',
+                    name: 'shell',
+                    arguments: '{"command":"ls"}',
+                },
+            },
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp_ws_reasoning_tool',
+                    output: [],
+                    usage: { input_tokens: 5, output_tokens: 6, total_tokens: 11 },
+                },
+            },
+        ]);
+    };
+    const loggingService = {
+        debug: (message, meta) => logs.push({ level: 'debug', message, meta }),
+        error: (message, meta) => logs.push({ level: 'error', message, meta }),
+        getCorrelationId: () => 'trace-log-2',
+    };
+    const sessionContextService = {
+        getContext: () => ({
+            sessionId: 'sess_ws_2',
+            sessionStartedAt: '2025-01-01T00:00:00.000Z',
+            firstUserMessagePreview: 'hello ws 2',
+            mode: 'websocket',
+            traceId: 'trace-session-2',
+        }),
+        runWithContext: (_context, fn) => fn(),
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    try {
+        const model = new CodexResponsesWSModel({ baseURL: 'https://api.openai.com', apiKey: 'test-key', _options: {} }, 'gpt-5-codex', tokenManager, undefined, loggingService, sessionContextService);
+        const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
+        await collect(model.getStreamedResponse(request));
+        expect(logs.length).toBe(2);
+        const receivedPayload = logs[1].meta.payload;
+        expect(receivedPayload.transport).toBe('websocket');
+        expect(receivedPayload.responseId).toBe('resp_ws_reasoning_tool');
+        expect(receivedPayload.outputTypes).toEqual(['reasoning', 'function_call']);
+        // Check unified payload matching HTTP/SSE structure
+        expect(receivedPayload.payload).toBeTruthy();
+        expect(receivedPayload.payload.id).toBe('resp_ws_reasoning_tool');
+        expect(receivedPayload.payload.usage).toEqual({ input_tokens: 5, output_tokens: 6, total_tokens: 11 });
+        expect(receivedPayload.payload.choices.length).toBe(1);
+        const delta = receivedPayload.payload.choices[0].delta;
+        expect(delta.reasoning).toBe('Let me think about this request.');
+        expect(delta.tool_calls).toEqual([
+            {
+                id: 'call_123',
+                type: 'function',
+                function: {
+                    name: 'shell',
+                    arguments: '{"command":"ls"}',
+                },
+            },
+        ]);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = original;
+    }
+});
+it.sequential('CodexResponsesModel.getResponse (unary) intercepts and runs as stream under the hood', async () => {
     const original = OpenAIResponsesModel.prototype._fetchResponse;
     let receivedStreamArg = false;
     OpenAIResponsesModel.prototype._fetchResponse = async function (_request, stream) {
@@ -386,20 +584,20 @@ test.serial('CodexResponsesModel.getResponse (unary) intercepts and runs as stre
         const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
         // Call getResponse which defaults to stream: false
         const response = await withTrace('test', () => model.getResponse(request));
-        t.true(receivedStreamArg, 'should have forced stream: true internally');
-        t.is(response.responseId, 'resp_unary');
-        t.is(response.output.length, 1);
-        t.is(response.output[0].id, 'msg_unary');
-        t.is(response.usage.totalTokens, 5);
+        expect(receivedStreamArg).toBe(true);
+        expect(response.responseId).toBe('resp_unary');
+        expect(response.output.length).toBe(1);
+        expect(response.output[0].id).toBe('msg_unary');
+        expect(response.usage.totalTokens).toBe(5);
     }
     finally {
         OpenAIResponsesModel.prototype._fetchResponse = original;
     }
 });
-test.serial('CodexResponsesWSModel.getResponse (unary) intercepts and runs as stream under the hood', async (t) => {
-    const original = TimedResponsesWSModel.prototype._fetchResponse;
+it.sequential('CodexResponsesWSModel.getResponse (unary) intercepts and runs as stream under the hood', async () => {
+    const original = OpenAIResponsesWSModel.prototype._fetchResponse;
     let receivedStreamArg = false;
-    TimedResponsesWSModel.prototype._fetchResponse = async function (_request, stream) {
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (_request, stream) {
         receivedStreamArg = stream;
         return makeStream([
             { type: 'response.created', response: { id: 'resp_ws_unary' } },
@@ -438,27 +636,32 @@ test.serial('CodexResponsesWSModel.getResponse (unary) intercepts and runs as st
         const request = { input: [], tracing: false, modelSettings: {}, tools: [], handoffs: [] };
         // Call getResponse which defaults to stream: false
         const response = await model.getResponse(request);
-        t.true(receivedStreamArg, 'should have forced stream: true internally');
-        t.is(response.responseId, 'resp_ws_unary');
-        t.is(response.output.length, 1);
-        t.is(response.output[0].id, 'msg_ws_unary');
-        t.is(response.usage.totalTokens, 7);
+        expect(receivedStreamArg).toBe(true);
+        expect(response.responseId).toBe('resp_ws_unary');
+        expect(response.output.length).toBe(1);
+        expect(response.output[0].id).toBe('msg_ws_unary');
+        expect(response.usage.totalTokens).toBe(7);
     }
     finally {
-        TimedResponsesWSModel.prototype._fetchResponse = original;
+        OpenAIResponsesWSModel.prototype._fetchResponse = original;
     }
 });
-test('wrapCodexStream throws a detailed stream error when receiving response.error event', async (t) => {
+it('wrapCodexStream throws a detailed stream error when receiving response.error event', async () => {
     const errorObj = { message: 'Some specific API error description' };
     const eventStream = wrapCodexStream(makeStream([{ type: 'response.error', error: errorObj }]));
-    const error = await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const _ of eventStream) {
         }
-    });
-    t.true(error instanceof Error);
-    t.is(error.message, 'Codex provider stream error: Some specific API error description');
+    }).rejects.toThrow('Codex provider stream error: Some specific API error description');
+});
+it('wrapCodexStream throws when receiving response.error event without error field', async () => {
+    const eventStream = wrapCodexStream(makeStream([{ type: 'response.error' }]));
+    await expect(async () => {
+        for await (const _ of eventStream) {
+        }
+    }).rejects.toThrow(/^Codex provider stream error:/);
 });
-test('wrapCodexStream throws a detailed provider error when receiving a failed response status', async (t) => {
+it('wrapCodexStream throws a detailed provider error when receiving a failed response status', async () => {
     const errorObj = { message: 'Model context length exceeded' };
     const eventStream = wrapCodexStream(makeStream([
         {
@@ -471,11 +674,470 @@ test('wrapCodexStream throws a detailed provider error when receiving a failed r
             },
         },
     ]));
-    const error = await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const _ of eventStream) {
         }
+    }).rejects.toThrow('Codex provider error: Model context length exceeded');
+});
+function createSleepRecorder() {
+    const delays = [];
+    return {
+        delays,
+        sleep: async (delayMs) => {
+            delays.push(delayMs);
+        },
+    };
+}
+const DEFAULT_STREAM_MAX_RETRIES = 5;
+it.sequential('CodexResponsesWSModel injects Codex previous response id and trims replayed tool-continuation input', async () => {
+    const seenRequests = [];
+    const toolOutput = {
+        type: 'function_call_result',
+        callId: 'call-read',
+        output: 'done',
+    };
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: seenRequests.length === 1 ? 'resp-1' : 'resp-2',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        });
+        for await (const _event of model.getStreamedResponse({
+            input: [{ role: 'user', type: 'message', content: 'inspect' }],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(2);
+        expect(seenRequests[0].modelSettings.providerData?.generate).toBe(false);
+        expect(seenRequests[0].input).toEqual([]);
+        expect(seenRequests[1].previousResponseId).toBe('resp-1');
+        expect(seenRequests[1].input).toEqual([{ role: 'user', type: 'message', content: 'inspect' }]);
+        for await (const _event of model.getStreamedResponse({
+            input: [
+                { role: 'user', type: 'message', content: 'inspect' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                { type: 'function_call', call_id: 'call-read', name: 'read_file', arguments: '{}' },
+                toolOutput,
+            ],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(3);
+        expect(seenRequests[2].previousResponseId).toBe('resp-2');
+        expect(seenRequests[2].input).toEqual([toolOutput]);
+        const latestUser = { role: 'user', type: 'message', content: 'summarize' };
+        for await (const _event of model.getStreamedResponse({
+            previousResponseId: 'resp-explicit',
+            input: [
+                { role: 'user', type: 'message', content: 'inspect' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Done.' }] },
+                latestUser,
+            ],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(4);
+        expect(seenRequests[3].previousResponseId).toBe('resp-explicit');
+        expect(seenRequests[3].input).toEqual([latestUser]);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel keeps every interleaved parallel tool output when trimming a tool-continuation delta', async () => {
+    const seenRequests = [];
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp-paired',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    // A prior Codex response issued five parallel function calls — four
+    // read_code_outline calls plus a shell. The reconstructed continuation
+    // history pairs each call with its result, and the shell pair lands last
+    // (it ran after the reads). Only that final result forms a contiguous
+    // trailing run, so the legacy delta trim kept just the shell output and
+    // dropped the four read outputs, which the server rejected with a 400
+    // ("No tool output found for function call …"). The fix must keep every
+    // output whose call was produced by the previous response.
+    const parallelReads = [1, 2, 3, 4].map((n) => ({
+        call: { type: 'function_call', call_id: `call-read-${n}`, name: 'read_code_outline', arguments: '{}' },
+        output: { type: 'function_call_result', callId: `call-read-${n}`, output: `outline-${n}` },
+    }));
+    const shellPair = {
+        call: { type: 'function_call', call_id: 'call-shell', name: 'shell', arguments: '{}' },
+        output: { type: 'function_call_result', callId: 'call-shell', output: 'grep result' },
+    };
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        });
+        for await (const _event of model.getStreamedResponse({
+            previousResponseId: 'resp-prev',
+            input: [
+                { role: 'user', type: 'message', content: 'inspect the repo' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                ...parallelReads.flatMap((pair) => [pair.call, pair.output]),
+                shellPair.call,
+                shellPair.output,
+            ],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(1);
+        expect(seenRequests[0].previousResponseId).toBe('resp-prev');
+        expect(seenRequests[0].input).toEqual([...parallelReads.map((pair) => pair.output), shellPair.output]);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel drops interleaved tool calls from an already-trimmed tool-continuation delta', async () => {
+    const seenRequests = [];
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp-trimmed-paired',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    const pairs = [1, 2].map((n) => ({
+        call: { type: 'function_call', call_id: `call-${n}`, name: 'read_code_outline', arguments: '{}' },
+        output: { type: 'function_call_result', callId: `call-${n}`, output: `outline-${n}` },
+    }));
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        });
+        for await (const _event of model.getStreamedResponse({
+            previousResponseId: 'resp-prev',
+            input: pairs.flatMap((pair) => [pair.call, pair.output]),
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(1);
+        expect(seenRequests[0].previousResponseId).toBe('resp-prev');
+        expect(seenRequests[0].input).toEqual(pairs.map((pair) => pair.output));
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel keeps interleaved outputs when function calls only carry item ids', async () => {
+    const seenRequests = [];
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp-item-id-paired',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    const pairs = [1, 2, 3].map((n) => ({
+        call: { type: 'function_call', id: `fc-${n}`, name: 'shell', arguments: '{}' },
+        output: { type: 'function_call_result', callId: `call-${n}`, output: `result-${n}` },
+    }));
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        });
+        for await (const _event of model.getStreamedResponse({
+            previousResponseId: 'resp-prev',
+            input: pairs.flatMap((pair) => [pair.call, pair.output]),
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(1);
+        expect(seenRequests[0].previousResponseId).toBe('resp-prev');
+        expect(seenRequests[0].input).toEqual(pairs.map((pair) => pair.output));
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel warms interleaved tool continuations into history before sending the delta', async () => {
+    const seenRequests = [];
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: seenRequests.length === 1 ? 'resp-warmup' : 'resp-main',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    const openingUser = { role: 'user', type: 'message', content: 'inspect the repo' };
+    const openingAssistant = {
+        role: 'assistant',
+        type: 'message',
+        content: [{ type: 'output_text', text: 'I will inspect it.' }],
+    };
+    const parallelReads = [1, 2].map((n) => ({
+        call: { type: 'function_call', call_id: `call-read-${n}`, name: 'read_code_outline', arguments: '{}' },
+        output: { type: 'function_call_result', callId: `call-read-${n}`, output: `outline-${n}` },
+    }));
+    const shellPair = {
+        call: { type: 'function_call', call_id: 'call-shell', name: 'shell', arguments: '{}' },
+        output: { type: 'function_call_result', callId: 'call-shell', output: 'grep result' },
+    };
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        });
+        for await (const _event of model.getStreamedResponse({
+            input: [
+                openingUser,
+                openingAssistant,
+                ...parallelReads.flatMap((pair) => [pair.call, pair.output]),
+                shellPair.call,
+                shellPair.output,
+            ],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        expect(seenRequests.length).toBe(2);
+        expect(seenRequests[0].modelSettings.providerData?.generate).toBe(false);
+        expect(seenRequests[0].previousResponseId).toBe(undefined);
+        expect(seenRequests[0].input).toEqual([
+            openingUser,
+            openingAssistant,
+            ...parallelReads.map((pair) => pair.call),
+            shellPair.call,
+        ]);
+        expect(seenRequests[1].previousResponseId).toBe('resp-warmup');
+        expect(seenRequests[1].input).toEqual([...parallelReads.map((pair) => pair.output), shellPair.output]);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel retries safe Codex warm-up failures before chaining the delta request', async () => {
+    const seenRequests = [];
+    const sleep = createSleepRecorder();
+    const safeWarmupError = Object.assign(new Error('Responses websocket connection closed before opening.'), {
+        code: 'connection_closed_before_opening',
     });
-    t.true(error instanceof Error);
-    t.is(error.message, 'Codex provider error: Model context length exceeded');
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        if (seenRequests.length === 1) {
+            throw safeWarmupError;
+        }
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: seenRequests.length === 2 ? 'resp-warmup' : 'resp-main',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        }, { sleep: sleep.sleep });
+        model.getRetryAdvice = async ({ error }) => error === safeWarmupError ? { suggested: true, replaySafety: 'safe' } : { suggested: false };
+        const latestUser = { role: 'user', type: 'message', content: 'next' };
+        await model.getResponse({
+            input: [
+                { role: 'user', type: 'message', content: 'first' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'first response' }] },
+                latestUser,
+            ],
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        });
+        expect(seenRequests.length).toBe(3);
+        expect(sleep.delays.length).toBe(1);
+        expect(sleep.delays[0] > 0).toBe(true);
+        expect(seenRequests[0].modelSettings.providerData?.generate).toBe(false);
+        expect(seenRequests[1].modelSettings.providerData?.generate).toBe(false);
+        expect(seenRequests[0].input).toEqual(seenRequests[1].input);
+        expect(seenRequests[2].previousResponseId).toBe('resp-warmup');
+        expect(seenRequests[2].input).toEqual([latestUser]);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
+});
+it.sequential('CodexResponsesWSModel falls back to full history without previous response id when safe Codex warm-up retries are exhausted', async () => {
+    const seenRequests = [];
+    const sleep = createSleepRecorder();
+    const safeWarmupError = Object.assign(new Error('Responses websocket connection closed before opening.'), {
+        code: 'connection_closed_before_opening',
+    });
+    const originalFetch = OpenAIResponsesWSModel.prototype._fetchResponse;
+    OpenAIResponsesWSModel.prototype._fetchResponse = async function (request) {
+        seenRequests.push(request);
+        if (seenRequests.length <= DEFAULT_STREAM_MAX_RETRIES + 1) {
+            throw safeWarmupError;
+        }
+        return makeStream([
+            {
+                type: 'response.completed',
+                response: {
+                    id: 'resp-main',
+                    output: [],
+                    usage: {},
+                },
+            },
+        ]);
+    };
+    const mockClient = {
+        baseURL: 'https://api.openai.com',
+        apiKey: 'test-key',
+        _options: {},
+    };
+    const tokenManager = {
+        getOrRefreshAccessToken: async () => 'token',
+        getAccountId: () => 'acc_123',
+    };
+    try {
+        const model = new CodexResponsesWSModel(mockClient, 'gpt-5-codex', tokenManager, undefined, undefined, {
+            getContext: () => ({ sessionId: 'session-1', traceId: 'trace-1' }),
+            runWithContext: (_context, fn) => fn(),
+        }, { sleep: sleep.sleep });
+        model.getRetryAdvice = async ({ error }) => error === safeWarmupError ? { suggested: true, replaySafety: 'safe' } : { suggested: false };
+        const fullInput = [
+            { role: 'user', type: 'message', content: 'first' },
+            { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'first response' }] },
+            { role: 'user', type: 'message', content: 'next' },
+        ];
+        for await (const _event of model.getStreamedResponse({
+            input: fullInput,
+            modelSettings: {},
+            tools: [],
+            handoffs: [],
+        })) {
+        }
+        const expectedTotalAttempts = DEFAULT_STREAM_MAX_RETRIES + 2;
+        expect(seenRequests.length).toBe(expectedTotalAttempts);
+        expect(sleep.delays.length).toBe(DEFAULT_STREAM_MAX_RETRIES);
+        expect(sleep.delays.every((delayMs) => delayMs > 0)).toBe(true);
+        expect(seenRequests
+            .slice(0, expectedTotalAttempts - 1)
+            .every((request) => request.modelSettings.providerData?.generate === false)).toBe(true);
+        expect(seenRequests[expectedTotalAttempts - 1].input).toEqual(fullInput);
+        expect(seenRequests[expectedTotalAttempts - 1].previousResponseId).toBe(undefined);
+        expect(seenRequests[expectedTotalAttempts - 1].modelSettings.providerData?.generate).toBe(undefined);
+    }
+    finally {
+        OpenAIResponsesWSModel.prototype._fetchResponse = originalFetch;
+    }
 });
 //# sourceMappingURL=codex-responses-model.test.js.map