@qduc/term2 0.7.2 → 0.8.0

package/dist/services/conversation-session.stream.test.js

@@ -0,0 +1,2099 @@
+// @ts-nocheck - Complex mock patterns deferred to follow-up
+import test from 'ava';
+import { ModelBehaviorError } from '@openai/agents';
+import { createConversationSession } from './conversation-session-factory.js';
+import { MockStream } from './test-helpers/mock-stream.js';
+const mockLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+    security: () => { },
+    setCorrelationId: () => { },
+    getCorrelationId: () => { },
+    clearCorrelationId: () => { },
+};
+const sessionContextService = {
+    runWithContext: (_context, fn) => fn(),
+    getContext: () => null,
+};
+test('run() streams ConversationEvents (text_delta → final) in order', async (t) => {
+    const events = [
+        { type: 'response.output_text.delta', delta: 'Hello' },
+        { type: 'response.output_text.delta', delta: ' world' },
+    ];
+    const stream = new MockStream(events);
+    stream.finalOutput = 'Hello world';
+    stream.lastResponseId = 'resp-1';
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('hi')) {
+        emitted.push(ev);
+    }
+    t.deepEqual(emitted.map((e) => e.type), ['text_delta', 'text_delta', 'final']);
+    t.is(emitted[0].delta, 'Hello');
+    t.is(emitted[0].fullText, 'Hello');
+    t.is(emitted[1].delta, ' world');
+    t.is(emitted[1].fullText, 'Hello world');
+    t.is(emitted[2].finalText, 'Hello world');
+});
+test('run() warns when completed stream history already contains duplicated tool pairs', async (t) => {
+    const warnings = [];
+    const logger = {
+        ...mockLogger,
+        warn: (message, meta) => warnings.push({ message, meta }),
+    };
+    const stream = new MockStream([]);
+    stream.history = [
+        { role: 'user', type: 'message', content: 'inspect' },
+        { type: 'function_call', callId: 'call-read', id: 'fc_1' },
+        { type: 'function_call_result', callId: 'call-read', id: 'fcr_1', output: 'hidden' },
+        { type: 'function_call', callId: 'call-read', id: 'fc_2' },
+        { type: 'function_call_result', callId: 'call-read', id: 'fcr_2', output: 'hidden again' },
+    ];
+    stream.newItems = stream.history.slice(1);
+    stream.state = { _generatedItems: stream.newItems };
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ev of session.run('hi')) {
+        // consume stream
+    }
+    const warning = warnings.find((entry) => entry.meta?.eventType === 'conversation.stream_history.replayed_tools');
+    t.truthy(warning);
+    t.is(warning.meta.phase, 'post_stream');
+    t.is(warning.meta.source, 'startStream');
+    t.is(warning.meta.historyDuplicatePairs, 1);
+    t.is(warning.meta.newItemsDuplicatePairs, 1);
+    t.is(warning.meta.stateGeneratedItemsDuplicatePairs, 1);
+    t.false('output' in warning.meta);
+});
+test('run() retries streamed recoverable errors without committing failed stream history', async (t) => {
+    class FailingStream extends MockStream {
+        constructor() {
+            super([]);
+            this.history = [
+                { role: 'user', type: 'message', content: 'retry me' },
+                { type: 'function_call', callId: 'failed-call', name: 'fake_tool', arguments: '{}' },
+                {
+                    type: 'function_call_result',
+                    callId: 'failed-call',
+                    name: 'fake_tool',
+                    output: { type: 'text', text: 'partial failed output' },
+                },
+            ];
+        }
+        async *[Symbol.asyncIterator]() {
+            yield { type: 'response.output_text.delta', delta: 'partial' };
+            throw new ModelBehaviorError('Tool fake_tool not found in agent Terminal Assistant.');
+        }
+    }
+    const successStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Recovered' }]);
+    successStream.finalOutput = 'Recovered';
+    successStream.history = [
+        { role: 'user', type: 'message', content: 'retry me' },
+        { role: 'assistant', type: 'message', status: 'completed', content: [{ type: 'output_text', text: 'Recovered' }] },
+    ];
+    const calls = [];
+    const mockClient = {
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream(input) {
+            calls.push(input);
+            return calls.length === 1 ? new FailingStream() : successStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+        retryOptions: { allowFreshStartRetries: false },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('retry me')) {
+        emitted.push(ev);
+    }
+    t.deepEqual(emitted.map((event) => event.type), ['text_delta', 'retry', 'text_delta', 'final']);
+    t.is(calls.length, 2);
+    t.is(calls[0].length, 1);
+    t.deepEqual(calls[1], [{ role: 'user', type: 'message', content: 'retry me' }]);
+});
+test('run() does not retry recoverable errors from a fresh start when disabled', async (t) => {
+    let calls = 0;
+    const mockClient = {
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream() {
+            calls++;
+            throw new ModelBehaviorError('Tool fake_tool not found in agent Terminal Assistant.');
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+        retryOptions: { allowFreshStartRetries: false },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    await t.throwsAsync(async () => {
+        for await (const ev of session.run('retry me')) {
+            emitted.push(ev);
+        }
+    });
+    t.is(calls, 1);
+    t.false(emitted.some((event) => event.type === 'retry'));
+    t.truthy(emitted.find((event) => event.type === 'error'));
+});
+test('run() exports completed tool pairs from a stream that later fails', async (t) => {
+    class FailingStream extends MockStream {
+        async *[Symbol.asyncIterator]() {
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call',
+                        id: 'fc_1',
+                        callId: 'call-read',
+                        name: 'read_file',
+                        arguments: '{}',
+                    },
+                },
+            };
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call_result',
+                        id: 'fcr_1',
+                        callId: 'call-read',
+                        name: 'read_file',
+                        output: 'contents',
+                    },
+                },
+            };
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call',
+                        id: 'fc_2',
+                        callId: 'call-write',
+                        name: 'apply_patch',
+                        arguments: '{}',
+                    },
+                },
+            };
+            throw new Error('context exceeded');
+        }
+    }
+    const mockClient = {
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream() {
+            return new FailingStream();
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    await t.throwsAsync(async () => {
+        for await (const _ev of session.run('inspect')) {
+            // consume stream
+        }
+    });
+    const state = stateFacade.exportState();
+    // Reconciled history: user message + completed call/result pair.
+    // The aborted second call has no result yet, so it is not pushed into history.
+    t.is(state.history.length, 3);
+    t.is(state.toolLedger.length, 2);
+    t.is(state.toolLedger[0].status, 'completed');
+    t.is(state.toolLedger[1].status, 'aborted');
+    t.deepEqual(state.toolLedger[0].historyItems.map((item) => item.callId), ['call-read', 'call-read']);
+});
+test('run() emits tool_recovery before error when a streamed turn fails after tool activity', async (t) => {
+    class FailingStream extends MockStream {
+        async *[Symbol.asyncIterator]() {
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call',
+                        id: 'fc_1',
+                        callId: 'call-read',
+                        name: 'read_file',
+                        arguments: '{}',
+                    },
+                },
+            };
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call_result',
+                        id: 'fcr_1',
+                        callId: 'call-read',
+                        name: 'read_file',
+                        output: 'contents',
+                    },
+                },
+            };
+            yield {
+                type: 'run_item_stream_event',
+                item: {
+                    rawItem: {
+                        type: 'function_call',
+                        id: 'fc_2',
+                        callId: 'call-write',
+                        name: 'apply_patch',
+                        arguments: '{}',
+                    },
+                },
+            };
+            throw new Error('context exceeded');
+        }
+    }
+    const mockClient = {
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream() {
+            return new FailingStream();
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    await t.throwsAsync(async () => {
+        for await (const ev of session.run('inspect')) {
+            emitted.push(ev);
+        }
+    });
+    const recovery = emitted.find((event) => event.type === 'tool_recovery');
+    t.truthy(recovery);
+    t.deepEqual(recovery.recoveredCallIds, ['call-read']);
+    t.deepEqual(recovery.droppedCallIds, ['call-write']);
+    t.true(recovery.message.includes('Recovered 1 completed'));
+    t.true(emitted.findIndex((event) => event.type === 'tool_recovery') < emitted.findIndex((event) => event.type === 'error'));
+    t.deepEqual(emitted.map((event) => event.type), ['tool_started', 'command_message', 'tool_started', 'tool_recovery', 'error']);
+    // Regression: after a mid-stream failure, completed tool call/result pairs
+    // captured by the ledger must be reconciled into canonical history so the
+    // next turn does not send two consecutive user messages with no tool record.
+    const state = stateFacade.exportState();
+    const types = state.history.map((item) => item.rawItem?.type ?? item.type);
+    t.true(types.includes('function_call'));
+    t.true(types.includes('function_call_result') || types.includes('function_call_output'));
+});
+test('importState() reconciles completed ledger pairs into canonical history', (t) => {
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: {},
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    stateFacade.importState({
+        previousResponseId: null,
+        history: [{ role: 'user', type: 'message', content: 'inspect' }],
+        toolLedger: [
+            {
+                turnId: 'turn-1',
+                callId: 'call-read',
+                toolName: 'read_file',
+                arguments: '{}',
+                status: 'completed',
+                startedAt: '2026-05-26T00:00:00.000Z',
+                completedAt: '2026-05-26T00:00:01.000Z',
+                historyItems: [
+                    { type: 'function_call', id: 'fc_1', callId: 'call-read', name: 'read_file', arguments: '{}' },
+                    { type: 'function_call_result', id: 'fcr_1', callId: 'call-read', output: 'contents' },
+                ],
+            },
+            {
+                turnId: 'turn-1',
+                callId: 'call-write',
+                toolName: 'apply_patch',
+                arguments: '{}',
+                status: 'aborted',
+                startedAt: '2026-05-26T00:00:02.000Z',
+            },
+        ],
+    });
+    const state = stateFacade.exportState();
+    t.is(state.history.length, 3);
+    t.is(state.history[1].callId, 'call-read');
+    t.is(state.history[2].callId, 'call-read');
+});
+test('run() allows a follow-up after a long non-chaining run expands full history', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'first' }]);
+    firstStream.finalOutput = 'first';
+    firstStream.history = Array.from({ length: 212 }, (_, index) => ({
+        role: index % 2 === 0 ? 'user' : 'assistant',
+        type: 'message',
+        content: `history-${index}`,
+        ...(index % 2 === 1 ? { status: 'completed' } : {}),
+    }));
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'second' }]);
+    secondStream.finalOutput = 'second';
+    const calls = [];
+    const mockClient = {
+        getProvider() {
+            return 'opencode';
+        },
+        async startStream(input) {
+            calls.push(input);
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    stateFacade.importState({
+        previousResponseId: null,
+        history: [{ role: 'user', type: 'message', content: 'seed' }],
+    });
+    const first = [];
+    for await (const ev of session.run('first')) {
+        first.push(ev);
+    }
+    const second = [];
+    for await (const ev of session.run('second')) {
+        second.push(ev);
+    }
+    t.is(calls.length, 2);
+    t.is(calls[0].length, 2);
+    t.true(calls[1].length > 212);
+    t.deepEqual(second.map((event) => event.type), ['text_delta', 'final']);
+});
+test('sendMessage() allows a follow-up after a long non-chaining run expands full history', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'ok' }]);
+    firstStream.finalOutput = 'ok';
+    firstStream.history = Array.from({ length: 212 }, (_, index) => ({
+        role: index % 2 === 0 ? 'user' : 'assistant',
+        type: 'message',
+        content: `history-${index}`,
+        ...(index % 2 === 1 ? { status: 'completed' } : {}),
+    }));
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'next' }]);
+    secondStream.finalOutput = 'next';
+    const calls = [];
+    const mockClient = {
+        getProvider() {
+            return 'opencode';
+        },
+        async startStream(input) {
+            calls.push(input);
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    stateFacade.importState({
+        previousResponseId: null,
+        history: [{ role: 'user', type: 'message', content: 'seed' }],
+    });
+    await terminalAdapter.sendMessage('first');
+    const second = await terminalAdapter.sendMessage('second');
+    t.is(second.type, 'response');
+    t.is(calls.length, 2);
+    t.true(calls[1].length > 212);
+});
+test('continue() streams events after approval decision', async (t) => {
+    const interruption = {
+        name: 'bash',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ command: 'echo hi' }),
+        callId: 'call-xyz',
+    };
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    initialStream.state = {
+        approveCalls: [],
+        rejectCalls: [],
+        approve(arg) {
+            this.approveCalls.push(arg);
+        },
+        reject(arg) {
+            this.rejectCalls.push(arg);
+        },
+    };
+    const continuationStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Approved run' }]);
+    continuationStream.finalOutput = 'Approved run';
+    const mockClient = {
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream(state) {
+            t.is(state, initialStream.state);
+            return continuationStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const first = [];
+    for await (const ev of session.run('run command')) {
+        first.push(ev);
+    }
+    t.is(first.length, 1);
+    t.is(first[0].type, 'approval_required');
+    t.is(first[0].approval.callId, 'call-xyz');
+    const cont = [];
+    for await (const ev of session.continueAfterApproval({ answer: 'y' })) {
+        cont.push(ev);
+    }
+    t.deepEqual(cont.map((e) => e.type), ['tool_started', 'text_delta', 'final']);
+    t.is(cont[0].type, 'tool_started');
+    t.is(cont[0].toolCallId, 'call-xyz');
+    t.is(cont[0].toolName, 'bash');
+    t.is(cont[1].delta, 'Approved run');
+    t.is(cont[2].finalText, 'Approved run');
+});
+test('run() retries malformed tool-call interruption before surfacing approval', async (t) => {
+    const malformedStream = new MockStream([]);
+    malformedStream.interruptions = [
+        {
+            name: 'shell',
+            callId: 'call-malformed',
+            arguments: '{"command":"echo hi"',
+            agent: { name: 'CLI Agent' },
+        },
+    ];
+    malformedStream.state = { approve() { }, reject() { } };
+    const successStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Recovered' }]);
+    successStream.finalOutput = 'Recovered';
+    successStream.lastResponseId = 'resp-recovered';
+    let startCalls = 0;
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        async startStream() {
+            startCalls++;
+            return startCalls === 1 ? malformedStream : successStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('run command')) {
+        emitted.push(ev);
+    }
+    t.is(startCalls, 2);
+    t.deepEqual(emitted.map((event) => event.type), ['retry', 'text_delta', 'final']);
+    t.is(emitted[0].retryType, 'parsing_error');
+    t.is(emitted[emitted.length - 1].finalText, 'Recovered');
+});
+test('sendMessage() preserves callId on approval_required terminal result', async (t) => {
+    const interruption = {
+        name: 'shell',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ command: 'echo hi' }),
+        callId: 'call-preserve-1',
+    };
+    const stream = new MockStream([]);
+    stream.interruptions = [interruption];
+    stream.state = {
+        approve() { },
+        reject() { },
+    };
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const result = await terminalAdapter.sendMessage('run command');
+    t.is(result.type, 'approval_required');
+    t.is(result.approval.callId, 'call-preserve-1');
+});
+test('handleApprovalDecision() preserves callId on subsequent approval_required terminal result', async (t) => {
+    const firstInterruption = {
+        name: 'shell',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ command: 'echo first' }),
+        callId: 'call-first',
+    };
+    const secondInterruption = {
+        name: 'apply_patch',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ path: 'a.ts' }),
+        callId: 'call-second',
+    };
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [firstInterruption];
+    initialStream.state = {
+        approveCalls: [],
+        approve(arg) {
+            this.approveCalls.push(arg);
+        },
+        reject() { },
+    };
+    const continuationStream = new MockStream([]);
+    continuationStream.interruptions = [secondInterruption];
+    const mockClient = {
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const first = await terminalAdapter.sendMessage('run command');
+    t.is(first.type, 'approval_required');
+    t.is(first.approval.callId, 'call-first');
+    const second = await terminalAdapter.handleApprovalDecision('y');
+    t.truthy(second);
+    t.is(second?.type, 'approval_required');
+    if (second?.type === 'approval_required') {
+        t.is(second.approval.callId, 'call-second');
+    }
+});
+test('run() sends text for OpenAI provider (server-side state)', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    let receivedInput;
+    const mockClient = {
+        async startStream(input) {
+            receivedInput = input;
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('Hello')) {
+        emitted.push(ev);
+    }
+    // OpenAI should receive just the text string (no getProvider means default 'openai')
+    t.is(typeof receivedInput, 'string');
+    t.is(receivedInput, 'Hello');
+    t.is(emitted[emitted.length - 1].type, 'final');
+});
+test('run() sends full history for non-OpenAI providers (client-side state)', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.history = [
+        { role: 'user', type: 'message', content: 'Hello' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'Response' }],
+        },
+    ];
+    let receivedInput;
+    const mockClient = {
+        async startStream(input) {
+            receivedInput = input;
+            return stream;
+        },
+        getProvider() {
+            return 'openrouter'; // Non-OpenAI provider
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('Hello')) {
+        emitted.push(ev);
+    }
+    // Non-OpenAI providers should receive full history array
+    t.true(Array.isArray(receivedInput));
+    t.is(receivedInput.length, 1); // Initial user message
+    t.is(receivedInput[0].role, 'user');
+    t.is(receivedInput[0].content, 'Hello');
+    t.is(emitted[emitted.length - 1].type, 'final');
+});
+test('run() preserves assistant text prefix when SDK full-history reconstruction strips it', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'I will inspect the files.' }]);
+    firstStream.finalOutput = 'I will inspect the files.';
+    firstStream.output = [];
+    firstStream.newItems = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'I will inspect the files.' }],
+        },
+    ];
+    firstStream.history = [
+        { role: 'user', type: 'message', content: 'Investigate cache issue' },
+        {
+            role: 'assistant',
+            content: null,
+            tool_calls: [
+                {
+                    id: 'call_read',
+                    type: 'function',
+                    function: { name: 'read_file', arguments: '{"path":"source/app.tsx"}' },
+                },
+            ],
+        },
+    ];
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Continuing.' }]);
+    secondStream.finalOutput = 'Continuing.';
+    secondStream.output = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Continuing.' }],
+        },
+    ];
+    const calls = [];
+    const mockClient = {
+        async startStream(input) {
+            calls.push(input);
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+        getProvider() {
+            return 'openrouter';
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('Investigate cache issue')) {
+        // consume events
+    }
+    for await (const _ of session.run('Continue after max turns')) {
+        // consume events
+    }
+    const secondInput = calls[1];
+    t.true(Array.isArray(secondInput));
+    t.deepEqual(secondInput.slice(0, 3), [
+        { role: 'user', type: 'message', content: 'Investigate cache issue' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'I will inspect the files.' }],
+        },
+        { role: 'user', type: 'message', content: 'Continue after max turns' },
+    ]);
+});
+test('run() sends full history for openai-compatible providers', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.history = [
+        { role: 'user', type: 'message', content: 'First message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'First response' }],
+        },
+        { role: 'user', type: 'message', content: 'Second message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'Response' }],
+        },
+    ];
+    let firstInput, secondInput;
+    let callCount = 0;
+    const mockClient = {
+        async startStream(input) {
+            callCount++;
+            if (callCount === 1) {
+                firstInput = input;
+            }
+            else {
+                secondInput = input;
+            }
+            return stream;
+        },
+        getProvider() {
+            return 'deepseek'; // Custom openai-compatible provider
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    // First message
+    for await (const ev of session.run('First message')) {
+        // consume events
+    }
+    // OpenAI-compatible provider should receive full history array
+    t.true(Array.isArray(firstInput));
+    t.is(firstInput.length, 1);
+    t.is(firstInput[0].content, 'First message');
+    // Second message should contain both previous and new message
+    for await (const ev of session.run('Second message')) {
+        // consume events
+    }
+    t.true(Array.isArray(secondInput));
+    t.true(secondInput.length >= 2, 'Second call should include conversation history');
+});
+test('run() chains follow-up turns for Codex provider over websocket', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'First response' }]);
+    firstStream.finalOutput = 'First response';
+    firstStream.lastResponseId = 'resp-codex-1';
+    firstStream.history = [
+        { role: 'user', type: 'message', content: 'First message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'First response' }],
+        },
+    ];
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Second response' }]);
+    secondStream.finalOutput = 'Second response';
+    secondStream.lastResponseId = 'resp-codex-2';
+    secondStream.history = [
+        ...firstStream.history,
+        { role: 'user', type: 'message', content: 'Second message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'Second response' }],
+        },
+    ];
+    const calls = [];
+    const mockClient = {
+        async startStream(input, opts) {
+            calls.push({ input, opts });
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+        getProvider() {
+            return 'codex';
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('First message')) {
+        // consume events
+    }
+    for await (const _ of session.run('Second message')) {
+        // consume events
+    }
+    t.is(typeof calls[0].input, 'string', 'Codex should send only the first user message on turn 1');
+    t.falsy(calls[0].opts.previousResponseId, 'Codex should not receive a previousResponseId on turn 1');
+    t.is(typeof calls[1].input, 'string', 'Codex should send only the next user message on turn 2');
+    t.is(calls[1].input, 'Second message');
+    t.is(calls[1].opts.previousResponseId, 'resp-codex-1', 'Codex should chain follow-up turns from turn 1');
+});
+test('sendMessage() returns usage from final event', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.completed = Promise.resolve({
+        usage: { inputTokens: 11, outputTokens: 7, totalTokens: 18 },
+    });
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    t.is(result.type, 'response');
+    t.deepEqual(result.usage, {
+        prompt_tokens: 11,
+        completion_tokens: 7,
+        total_tokens: 18,
+    });
+});
+test('handleApprovalDecision() returns usage from final event', async (t) => {
+    const interruption = {
+        name: 'bash',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ command: 'echo hi' }),
+        callId: 'call-xyz',
+    };
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    initialStream.state = {
+        approve() { },
+        reject() { },
+    };
+    const continuationStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Approved run' }]);
+    continuationStream.finalOutput = 'Approved run';
+    continuationStream.completed = Promise.resolve({
+        usage: { inputTokens: 21, outputTokens: 9, totalTokens: 30 },
+    });
+    const mockClient = {
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const approvalResult = await terminalAdapter.sendMessage('run command');
+    t.is(approvalResult.type, 'approval_required');
+    const finalResult = await terminalAdapter.handleApprovalDecision('y');
+    t.is(finalResult.type, 'response');
+    t.deepEqual(finalResult.usage, {
+        prompt_tokens: 21,
+        completion_tokens: 9,
+        total_tokens: 30,
+    });
+});
+test('sendMessage() logs usage handoff at DEBUG level', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.completed = Promise.resolve({
+        usage: { inputTokens: 4, outputTokens: 6, totalTokens: 10 },
+    });
+    const debugLogs = [];
+    const logger = {
+        ...mockLogger,
+        debug: (message, meta) => {
+            debugLogs.push({ message, meta });
+        },
+    };
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    await terminalAdapter.sendMessage('Hello');
+    const hasUsageReturnLog = debugLogs.some((log) => log.message === 'sendMessage returning response' && log.meta?.hasUsage === true);
+    t.true(hasUsageReturnLog);
+});
+test('logs diagnostics when usage is missing in stream completion', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.completed = Promise.resolve({ foo: 'bar' });
+    const debugLogs = [];
+    const logger = {
+        ...mockLogger,
+        debug: (message, meta) => {
+            debugLogs.push({ message, meta });
+        },
+    };
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    await terminalAdapter.sendMessage('Hello');
+    const missingUsageLog = debugLogs.find((log) => log.message === 'No usage found in stream completion');
+    t.truthy(missingUsageLog);
+    t.true(Array.isArray(missingUsageLog.meta?.completedResultKeys), 'completedResultKeys should be present');
+});
+test('sendMessage() extracts usage from stream.rawResponses when completed is void', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    stream.completed = Promise.resolve(undefined);
+    stream.rawResponses = [{ usage: { inputTokens: 13, outputTokens: 8, totalTokens: 21 } }];
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    t.is(result.type, 'response');
+    t.deepEqual(result.usage, {
+        prompt_tokens: 13,
+        completion_tokens: 8,
+        total_tokens: 21,
+    });
+});
+test('sendMessage() preserves cache usage from streaming events when final usage omits it', async (t) => {
+    const events = [
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    usage: {
+                        prompt_tokens: 100,
+                        completion_tokens: 20,
+                        total_tokens: 120,
+                        prompt_tokens_details: { cached_tokens: 60 },
+                    },
+                },
+            },
+        },
+    ];
+    const stream = new MockStream(events, {
+        usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+    });
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    t.is(result.type, 'response');
+    t.deepEqual(result.usage, {
+        prompt_tokens: 100,
+        completion_tokens: 20,
+        total_tokens: 120,
+        cache_read_tokens: 60,
+    });
+});
+test('run() emits usage_update when usage is nested in event.data (raw_model_stream_event)', async (t) => {
+    // Simulates a raw_model_stream_event with type 'response.completed' where
+    // usage lives at event.data.response.usage
+    const events = [
+        { type: 'response.output_text.delta', delta: 'Hello' },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'response.completed',
+                response: {
+                    usage: { input_tokens: 50, output_tokens: 25 },
+                },
+            },
+        },
+    ];
+    const stream = new MockStream(events);
+    stream.finalOutput = 'Hello';
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    t.true(usageEvents.length >= 1, 'Should emit at least one usage_update event');
+    t.is(usageEvents[0].usage.prompt_tokens, 50);
+    t.is(usageEvents[0].usage.completion_tokens, 25);
+    t.is(usageEvents[0].usage.total_tokens, 75);
+});
+test('run() emits usage_update when raw model stream usage is nested in event.data.event', async (t) => {
+    const events = [
+        { type: 'response.output_text.delta', delta: 'Hello' },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    id: '8d03b4e8-46ab-45f7-aed4-670157c3dd6d',
+                    object: 'chat.completion.chunk',
+                    created: 1778912418,
+                    model: 'deepseek-v4-flash',
+                    usage: { prompt_tokens: 8, completion_tokens: 3, total_tokens: 11 },
+                },
+                providerData: {
+                    rawModelEventSource: 'openai-chat-completions',
+                },
+            },
+        },
+    ];
+    const stream = new MockStream(events);
+    stream.finalOutput = 'Hello';
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    t.true(usageEvents.length >= 1, 'Should emit at least one usage_update event');
+    t.is(usageEvents[0].usage.prompt_tokens, 8);
+    t.is(usageEvents[0].usage.completion_tokens, 3);
+    t.is(usageEvents[0].usage.total_tokens, 11);
+});
+test('run() emits usage_update when usage is at top level of event', async (t) => {
+    // Simulates events that have usage directly on the event (e.g. response.done)
+    const events = [
+        { type: 'response.output_text.delta', delta: 'Hello' },
+        {
+            type: 'response.done',
+            response: {
+                usage: { input_tokens: 100, output_tokens: 50 },
+            },
+        },
+    ];
+    const stream = new MockStream(events);
+    stream.finalOutput = 'Hello';
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    for await (const ev of session.run('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    t.true(usageEvents.length >= 1, 'Should emit at least one usage_update event');
+    t.is(usageEvents[0].usage.prompt_tokens, 100);
+    t.is(usageEvents[0].usage.completion_tokens, 50);
+    t.is(usageEvents[0].usage.total_tokens, 150);
+});
+test('undoLastUserTurn() returns { text, imageCount: 0 } after a completed run', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Reply' }]);
+    stream.finalOutput = 'Reply';
+    stream.history = [
+        { role: 'user', type: 'message', content: 'hello' },
+        { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Reply' }] },
+    ];
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+        getProvider() {
+            return 'openrouter';
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('hello')) {
+        // consume
+    }
+    const result = stateFacade.undoLastUserTurn();
+    t.deepEqual(result, { text: 'hello', imageCount: 0 });
+});
+test('undoLastUserTurn() returns null when no genuine user turn exists', async (t) => {
+    const mockClient = {
+        async startStream() {
+            return new MockStream([]);
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const result = stateFacade.undoLastUserTurn();
+    t.is(result, null);
+});
+test('generation guard: gated run store write is skipped after undoLastUserTurn', async (t) => {
+    // Turn 1: run to completion so the store has msg1's history.
+    const stream1 = new MockStream([{ type: 'response.output_text.delta', delta: 'Reply1' }]);
+    stream1.finalOutput = 'Reply1';
+    stream1.history = [
+        { role: 'user', type: 'message', content: 'msg1' },
+        { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Reply1' }] },
+    ];
+    // Turn 2 (gated): a stream that yields one event then waits for a gate promise before "finishing".
+    // We implement this by resolving a deferred to control when the async iterator returns.
+    let gateResolve;
+    const gate = new Promise((resolve) => {
+        gateResolve = resolve;
+    });
+    class GatedStream {
+        constructor() {
+            this.lastResponseId = 'resp_gated';
+            this.interruptions = [];
+            this.state = {};
+            this.newItems = [];
+            this.history = [
+                { role: 'user', type: 'message', content: 'msg2' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Reply2' }] },
+            ];
+            this.finalOutput = 'Reply2';
+        }
+        async *[Symbol.asyncIterator]() {
+            yield { type: 'response.output_text.delta', delta: 'Reply2' };
+            await gate;
+        }
+    }
+    // Turn 3: capture the input so we can assert the history array.
+    let msg3Input;
+    const stream3 = new MockStream([{ type: 'response.output_text.delta', delta: 'Reply3' }]);
+    stream3.finalOutput = 'Reply3';
+    stream3.history = [
+        { role: 'user', type: 'message', content: 'msg1' },
+        { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Reply1' }] },
+        { role: 'user', type: 'message', content: 'msg3' },
+        { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'Reply3' }] },
+    ];
+    let callCount = 0;
+    const mockClient = {
+        async startStream(input) {
+            callCount++;
+            if (callCount === 1)
+                return stream1;
+            if (callCount === 2)
+                return new GatedStream();
+            msg3Input = input;
+            return stream3;
+        },
+        getProvider() {
+            return 'openrouter';
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    // (a) Run msg1 to completion — store now has msg1 + Reply1.
+    for await (const _ of session.run('msg1')) {
+        // consume
+    }
+    // (b) Begin msg2 in a background IIFE — it will block on the gate.
+    const msg2Done = (async () => {
+        const events = [];
+        for await (const ev of session.run('msg2')) {
+            events.push(ev);
+        }
+        return events;
+    })();
+    // Give the IIFE a chance to start and reach the gate (one microtask tick is enough).
+    await Promise.resolve();
+    // (c) While msg2 is gated, undo it — bumps generation.
+    const undone = stateFacade.undoLastUserTurn();
+    t.deepEqual(undone, { text: 'msg2', imageCount: 0 });
+    // (d) Resolve the gate so the gated run completes (but its store write should be skipped).
+    gateResolve();
+    await msg2Done;
+    // (e) Issue msg3 and capture the input passed to startStream.
+    for await (const _ of session.run('msg3')) {
+        // consume
+    }
+    // The input to startStream for msg3 must contain msg1 but NOT msg2.
+    t.true(Array.isArray(msg3Input), 'msg3 should receive history array');
+    const contents = msg3Input.map((item) => item.content);
+    t.true(contents.includes('msg1'), 'history should contain msg1');
+    t.false(contents.includes('msg2'), 'history must NOT contain msg2 (generation guard worked)');
+});
+test('run() throws AbortError when the stream is cancelled/aborted', async (t) => {
+    const stream = new MockStream([]);
+    stream.cancelled = true;
+    const mockClient = {
+        async startStream() {
+            return stream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    await t.throwsAsync(async () => {
+        for await (const _ of session.run('hi')) {
+            void _;
+        }
+    }, { name: 'AbortError' });
+});
+test('run() sends full history after undo on a chaining provider (Responses API)', async (t) => {
+    // Simulate a chaining provider (OpenAI) with a two-turn conversation, then undo.
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'First reply' }]);
+    firstStream.finalOutput = 'First reply';
+    firstStream.lastResponseId = 'resp-turn1';
+    firstStream.history = [
+        { role: 'user', type: 'message', content: 'First message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'First reply' }],
+        },
+    ];
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Second reply' }]);
+    secondStream.finalOutput = 'Second reply';
+    secondStream.lastResponseId = 'resp-turn2';
+    secondStream.history = [
+        { role: 'user', type: 'message', content: 'First message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'First reply' }],
+        },
+        { role: 'user', type: 'message', content: 'Second message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Second reply' }],
+        },
+    ];
+    const afterUndoStream = new MockStream([{ type: 'response.output_text.delta', delta: 'After undo reply' }]);
+    afterUndoStream.finalOutput = 'After undo reply';
+    afterUndoStream.lastResponseId = 'resp-after-undo';
+    afterUndoStream.history = [
+        { role: 'user', type: 'message', content: 'First message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'First reply' }],
+        },
+        { role: 'user', type: 'message', content: 'Retry message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'After undo reply' }],
+        },
+    ];
+    const calls = [];
+    let callCount = 0;
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        async startStream(input, opts) {
+            callCount++;
+            calls.push({ input, opts });
+            if (callCount === 1)
+                return firstStream;
+            if (callCount === 2)
+                return secondStream;
+            return afterUndoStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    // Turn 1: chaining provider sends just the text string
+    for await (const _ of session.run('First message')) {
+    }
+    t.is(typeof calls[0].input, 'string', 'Turn 1: chaining sends just the text');
+    t.falsy(calls[0].opts.previousResponseId);
+    // Turn 2: chaining provider uses previousResponseId from turn 1
+    for await (const _ of session.run('Second message')) {
+    }
+    t.is(typeof calls[1].input, 'string', 'Turn 2: chaining sends just the text');
+    // Undo: removes second user turn, nullifies previousResponseId
+    stateFacade.undoLastUserTurn();
+    // Turn 3 (after undo): must send full history, NOT just the latest message
+    for await (const _ of session.run('Retry message')) {
+    }
+    const thirdCall = calls[2];
+    t.true(Array.isArray(thirdCall.input), 'Turn after undo must send full history array');
+    t.true(thirdCall.input.length >= 2, 'Full history includes prior turns');
+    t.falsy(thirdCall.opts.previousResponseId, 'No previousResponseId after undo');
+});
+test('run() resyncs full history after resume before returning to chaining provider', async (t) => {
+    const firstResumedStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Resynced reply' }]);
+    firstResumedStream.finalOutput = 'Resynced reply';
+    firstResumedStream.lastResponseId = 'resp-resynced';
+    firstResumedStream.history = [
+        { role: 'user', type: 'message', content: 'Earlier message' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Earlier reply' }],
+        },
+        { role: 'user', type: 'message', content: 'Resume follow-up' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Resynced reply' }],
+        },
+    ];
+    const chainedStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Chained reply' }]);
+    chainedStream.finalOutput = 'Chained reply';
+    chainedStream.lastResponseId = 'resp-chained';
+    chainedStream.output = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Chained reply' }],
+        },
+    ];
+    const calls = [];
+    const streams = [firstResumedStream, chainedStream];
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        async startStream(input, opts) {
+            calls.push({ input, opts });
+            return streams.shift();
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 'resumed-session',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    stateFacade.importState({
+        history: [
+            { role: 'user', type: 'message', content: 'Earlier message' },
+            {
+                role: 'assistant',
+                type: 'message',
+                status: 'completed',
+                content: [{ type: 'output_text', text: 'Earlier reply' }],
+            },
+        ],
+        previousResponseId: 'expired-response-id',
+        toolLedger: [],
+        updatedAt: new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString(),
+    });
+    for await (const _ of session.run('Resume follow-up')) {
+    }
+    t.true(Array.isArray(calls[0].input), 'First resumed turn must resend full history');
+    t.falsy(calls[0].opts.previousResponseId, 'First resumed turn must not use persisted previousResponseId');
+    t.deepEqual(calls[0].input.map((item) => item.content), ['Earlier message', [{ type: 'output_text', text: 'Earlier reply' }], 'Resume follow-up']);
+    for await (const _ of session.run('Second follow-up')) {
+    }
+    t.is(calls[1].input, 'Second follow-up', 'Second resumed turn should return to delta chaining');
+    t.is(calls[1].opts.previousResponseId, 'resp-resynced');
+});
+test('run() ignores a stale completion after importState() bumps generation', async (t) => {
+    let releaseGate;
+    const gate = new Promise((resolve) => {
+        releaseGate = resolve;
+    });
+    class GatedStream extends MockStream {
+        constructor() {
+            super([]);
+            this.lastResponseId = 'resp-stale';
+            this.finalOutput = 'stale reply';
+            this.history = [
+                { role: 'user', type: 'message', content: 'stale request' },
+                {
+                    role: 'assistant',
+                    type: 'message',
+                    status: 'completed',
+                    content: [{ type: 'output_text', text: 'stale reply' }],
+                },
+            ];
+            this.output = [
+                {
+                    role: 'assistant',
+                    type: 'message',
+                    status: 'completed',
+                    content: [{ type: 'output_text', text: 'stale reply' }],
+                },
+            ];
+        }
+        async *[Symbol.asyncIterator]() {
+            yield { type: 'response.output_text.delta', delta: 'stale reply' };
+            await gate;
+        }
+    }
+    const freshStream = new MockStream([{ type: 'response.output_text.delta', delta: 'fresh reply' }]);
+    freshStream.finalOutput = 'fresh reply';
+    freshStream.lastResponseId = 'resp-fresh';
+    const calls = [];
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        async startStream(input, opts) {
+            calls.push({ input, opts });
+            return calls.length === 1 ? new GatedStream() : freshStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const staleEvents = [];
+    const staleRun = (async () => {
+        for await (const event of session.run('stale request')) {
+            staleEvents.push(event);
+        }
+    })();
+    await Promise.resolve();
+    stateFacade.importState({
+        history: [],
+        previousResponseId: null,
+        toolLedger: [],
+        updatedAt: new Date().toISOString(),
+    });
+    releaseGate();
+    await staleRun;
+    t.deepEqual(staleEvents, []);
+    t.deepEqual(stateFacade.exportState().history, []);
+    for await (const _ of session.run('fresh request')) {
+        // consume
+    }
+    t.is(calls[1].input, 'fresh request');
+    t.falsy(calls[1].opts.previousResponseId);
+});
+test('run() with image attachment does not throw when supportsChaining is true', async (t) => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Reply' }]);
+    stream.finalOutput = 'Reply';
+    let receivedInput;
+    const mockClient = {
+        async startStream(input) {
+            receivedInput = input;
+            return stream;
+        },
+        getProvider() {
+            return 'openai';
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const turn = {
+        text: 'describe this image',
+        images: [
+            {
+                id: 'img1',
+                data: 'base64data',
+                mimeType: 'image/png',
+                byteSize: 100,
+                displayNumber: 1,
+            },
+        ],
+    };
+    const emitted = [];
+    for await (const ev of session.run(turn)) {
+        emitted.push(ev);
+    }
+    // Under conversation chaining (supportsChaining is true), if it contains an image,
+    // it should send the input wrapped in an array, not as a single object, to avoid
+    // "originalInput is not iterable" when agents SDK processes it.
+    t.true(Array.isArray(receivedInput), 'Input should be wrapped in an array');
+    t.is(receivedInput.length, 1);
+    t.is(receivedInput[0].role, 'user');
+    t.is(receivedInput[0].content[0].type, 'input_text');
+    t.is(receivedInput[0].content[1].type, 'input_image');
+});
+test('previewLargeUncachedInput() does not mutate history or consume pending mode notice', (t) => {
+    const mockClient = {
+        getProvider() {
+            return 'codex';
+        },
+    };
+    const settings = new Map([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+        ['app.planMode', true],
+    ]);
+    const settingsService = {
+        get(key) {
+            return settings.get(key);
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    stateFacade.queueModeNotice('Plan mode enabled');
+    const before = stateFacade.exportState();
+    const decision = stateFacade.previewLargeUncachedInput('hello', 1_000);
+    t.is(decision.action, 'allow');
+    t.deepEqual(stateFacade.exportState(), before);
+});
+test('previewLargeUncachedInput() estimates from outgoing input instead of accepting accumulated session usage overrides', (t) => {
+    const mockClient = {
+        getProvider() {
+            return 'codex';
+        },
+    };
+    const settings = new Map([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+    ]);
+    const settingsService = {
+        get(key) {
+            return settings.get(key);
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const large = 'x'.repeat(64_000 * 4);
+    const decision = stateFacade.previewLargeUncachedInput(large, 1_000);
+    t.is(decision.action, 'allow');
+    t.true(decision.estimatedTokens >= 64_000);
+});
+test('sendMessage() records successful large guard state after provider request completion', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'ok' }]);
+    firstStream.finalOutput = 'ok';
+    firstStream.history = [
+        { role: 'user', type: 'message', content: 'first' },
+        { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'ok' }] },
+    ];
+    const mockClient = {
+        getProvider() {
+            return 'codex';
+        },
+        async startStream() {
+            return firstStream;
+        },
+    };
+    const settings = new Map([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+    ]);
+    const settingsService = {
+        get(key) {
+            return settings.get(key);
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const large = 'x'.repeat(64_000 * 4);
+    t.is(stateFacade.previewLargeUncachedInput(large, 1_000).action, 'allow');
+    await terminalAdapter.sendMessage(large);
+    const decision = stateFacade.previewLargeUncachedInput(large, Date.now() + 5 * 60 * 1_000 + 1);
+    t.is(decision.action, 'warn');
+    t.true(decision.reasons.includes('idle_timeout'));
+});
+test('run() yields an error event carrying droppedUserMessage when startStream fails pre-stream', async (t) => {
+    const mockClient = {
+        async startStream() {
+            throw new Error('upstream 500');
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    let thrown = null;
+    try {
+        for await (const ev of session.run('hello')) {
+            emitted.push(ev);
+        }
+    }
+    catch (e) {
+        thrown = e;
+    }
+    // The run wraps the throw inside the catch and re-throws after yielding the
+    // error event, but consumer-cleanup may swallow the re-throw — what matters
+    // is that the error event carried the drop signal.
+    const errorEvent = emitted.find((e) => e.type === 'error');
+    t.truthy(errorEvent, 'should emit an error event');
+    t.truthy(errorEvent.droppedUserMessage, 'error event should carry droppedUserMessage');
+    t.is(errorEvent.droppedUserMessage.text, 'hello');
+    t.is(errorEvent.droppedUserMessage.imageCount, 0);
+    // And the store should have rolled back the user turn so /undo state is clean.
+    t.is(stateFacade.listUserTurns().length, 0);
+    t.truthy(thrown);
+});
+test('run() omits droppedUserMessage when no user turn was added (skipUserMessage)', async (t) => {
+    const mockClient = {
+        async startStream() {
+            throw new Error('upstream 500');
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    const emitted = [];
+    try {
+        for await (const ev of session.run('hello', { skipUserMessage: true })) {
+            emitted.push(ev);
+        }
+    }
+    catch {
+        // expected
+    }
+    const errorEvent = emitted.find((e) => e.type === 'error');
+    t.truthy(errorEvent);
+    t.is(errorEvent.droppedUserMessage, undefined);
+});
+test('run() emits user_message_consumed_for_abort when an aborted approval is being resolved', async (t) => {
+    // Plant an aborted approval context directly via approvalState so the
+    // session's consumeAborted() picks it up. The downstream fake-execution
+    // path will throw (no real interruption), but we only care about event order.
+    const mockClient = {
+        async startStream() {
+            throw new Error('not used');
+        },
+        async continueRunStream() {
+            throw new Error('continue not implemented in test');
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    approvalState.setPending({
+        state: {},
+        interruption: { type: 'tool_approval_item', rawItem: { name: 'noop', callId: 'c1' } },
+        emittedCommandIds: new Set(),
+        toolCallArgumentsById: new Map(),
+    });
+    approvalState.abortPending();
+    const emitted = [];
+    try {
+        for await (const ev of session.run('follow up text')) {
+            emitted.push(ev);
+        }
+    }
+    catch {
+        // expected — downstream paths will fail in this minimal mock
+    }
+    const idx = emitted.findIndex((e) => e.type === 'user_message_consumed_for_abort');
+    t.true(idx >= 0, 'must emit user_message_consumed_for_abort');
+    // The store must not have a genuine user turn for this input.
+    t.is(stateFacade.listUserTurns().length, 0);
+});
+test('switchProvider() clears provider continuity but preserves transcript history', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'First reply' }]);
+    firstStream.finalOutput = 'First reply';
+    firstStream.lastResponseId = 'resp-openai-1';
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Second reply' }]);
+    secondStream.finalOutput = 'Second reply';
+    secondStream.lastResponseId = 'resp-openrouter-1';
+    const calls = [];
+    let provider = 'openai';
+    let clearConversationsCalls = 0;
+    const mockClient = {
+        getProvider() {
+            return provider;
+        },
+        setProvider(nextProvider) {
+            provider = nextProvider;
+        },
+        clearConversations() {
+            clearConversationsCalls++;
+        },
+        async startStream(input, opts) {
+            calls.push({ input, opts, provider });
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('First message')) {
+    }
+    approvalState.setPending({
+        state: {},
+        interruption: { type: 'tool_approval_item', rawItem: { name: 'noop', callId: 'c1' } },
+        emittedCommandIds: new Set(),
+        toolCallArgumentsById: new Map(),
+    });
+    approvalState.abortPending();
+    runtimeController.switchProvider('openrouter');
+    t.is(await terminalAdapter.handleApprovalDecision('y'), null, 'pending approval should be cleared on provider switch');
+    const emitted = [];
+    for await (const ev of session.run('Second message')) {
+        emitted.push(ev);
+    }
+    t.is(clearConversationsCalls, 1);
+    t.is(provider, 'openrouter');
+    t.false(emitted.some((event) => event.type === 'user_message_consumed_for_abort'), 'aborted approval state should be cleared on provider switch');
+    const secondCall = calls[1];
+    t.true(Array.isArray(secondCall.input), 'provider switch should force full-history replay on the next turn');
+    t.true(secondCall.input.length >= 2, 'replayed history should include the earlier user turn');
+    t.falsy(secondCall.opts.previousResponseId, 'provider switch must discard previousResponseId from the old provider');
+    t.deepEqual(stateFacade.listUserTurns().map((turn) => turn.text), ['First message', 'Second message']);
+});
+test('setModel() clears provider continuity and forces full-history replay on the next turn', async (t) => {
+    const firstStream = new MockStream([{ type: 'response.output_text.delta', delta: 'First reply' }]);
+    firstStream.finalOutput = 'First reply';
+    firstStream.lastResponseId = 'resp-model-1';
+    const secondStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Second reply' }]);
+    secondStream.finalOutput = 'Second reply';
+    secondStream.lastResponseId = 'resp-model-2';
+    const calls = [];
+    const models = [];
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        setModel(model) {
+            models.push(model);
+        },
+        clearConversations() { },
+        async startStream(input, opts) {
+            calls.push({ input, opts });
+            return calls.length === 1 ? firstStream : secondStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('First message')) {
+    }
+    runtimeController.setModel('gpt-next');
+    for await (const _ of session.run('Second message')) {
+    }
+    t.deepEqual(models, ['gpt-next']);
+    t.true(Array.isArray(calls[1].input), 'model change should force a full-history replay');
+    t.falsy(calls[1].opts.previousResponseId, 'model change must discard previousResponseId');
+});
+test('undoLastUserTurn() clears tool ledger so stale tool calls are not re-injected on retry', async (t) => {
+    // Turn 1: run with a tool call so the tool ledger records an entry.
+    const toolCallId = 'call_abc123';
+    const turn1Events = [
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call',
+                    callId: toolCallId,
+                    name: 'shell',
+                    arguments: '{"command":"echo hello"}',
+                },
+            },
+        },
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call_output',
+                    callId: toolCallId,
+                    output: 'hello',
+                },
+            },
+        },
+        { type: 'response.output_text.delta', delta: 'Done' },
+    ];
+    const stream1 = new MockStream(turn1Events);
+    stream1.finalOutput = 'Done';
+    stream1.history = [
+        { role: 'user', type: 'message', content: 'run echo hello' },
+        {
+            type: 'function_call',
+            callId: toolCallId,
+            name: 'shell',
+            arguments: '{"command":"echo hello"}',
+        },
+        {
+            type: 'function_call_output',
+            callId: toolCallId,
+            output: 'hello',
+        },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'Done' }],
+        },
+    ];
+    // Turn 2 (after undo + retry): capture what input the model receives.
+    let retryInput;
+    const stream2 = new MockStream([{ type: 'response.output_text.delta', delta: 'Retried' }]);
+    stream2.finalOutput = 'Retried';
+    stream2.history = [
+        { role: 'user', type: 'message', content: 'run echo hello' },
+        {
+            role: 'assistant',
+            type: 'message',
+            content: [{ type: 'output_text', text: 'Retried' }],
+        },
+    ];
+    let callCount = 0;
+    const mockClient = {
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream(input) {
+            callCount++;
+            if (callCount === 1)
+                return stream1;
+            retryInput = input;
+            return stream2;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    // Run turn 1 to completion — tool ledger now has the tool call entry.
+    for await (const _ of session.run('run echo hello')) {
+        // consume
+    }
+    // Verify ledger has entries before undo.
+    const stateBefore = stateFacade.exportState();
+    t.true(stateBefore.toolLedger.length > 0, 'tool ledger should have entries before undo');
+    // Undo the turn.
+    stateFacade.undoLastUserTurn();
+    // Verify ledger is cleared after undo.
+    const stateAfter = stateFacade.exportState();
+    t.is(stateAfter.toolLedger.length, 0, 'tool ledger must be empty after undo');
+    // Retry the same message — the model must NOT see the old tool call/result pair.
+    for await (const _ of session.run('run echo hello')) {
+        // consume
+    }
+    t.true(Array.isArray(retryInput), 'retry should send full history');
+    const callIds = retryInput.filter((item) => item.callId || item.call_id).map((item) => item.callId || item.call_id);
+    t.false(callIds.includes(toolCallId), 'retried history must NOT contain old tool call IDs');
+});
+test('undoLastUserTurn() preserves earlier tool ledger entries that still belong to retained turns', async (t) => {
+    const firstToolCallId = 'call_first';
+    const secondToolCallId = 'call_second';
+    const stream1 = new MockStream([
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call',
+                    callId: firstToolCallId,
+                    name: 'shell',
+                    arguments: '{"command":"echo first"}',
+                },
+            },
+        },
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call_output',
+                    callId: firstToolCallId,
+                    output: 'first',
+                },
+            },
+        },
+        { type: 'response.output_text.delta', delta: 'First done' },
+    ]);
+    stream1.finalOutput = 'First done';
+    stream1.lastResponseId = 'resp-first';
+    stream1.output = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'First done' }],
+        },
+    ];
+    const stream2 = new MockStream([
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call',
+                    callId: secondToolCallId,
+                    name: 'shell',
+                    arguments: '{"command":"echo second"}',
+                },
+            },
+        },
+        {
+            type: 'run_item_stream_event',
+            item: {
+                rawItem: {
+                    type: 'function_call_output',
+                    callId: secondToolCallId,
+                    output: 'second',
+                },
+            },
+        },
+        { type: 'response.output_text.delta', delta: 'Second done' },
+    ]);
+    stream2.finalOutput = 'Second done';
+    stream2.lastResponseId = 'resp-second';
+    stream2.output = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Second done' }],
+        },
+    ];
+    let retryInput;
+    const retryStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Retry done' }]);
+    retryStream.finalOutput = 'Retry done';
+    retryStream.lastResponseId = 'resp-retry';
+    retryStream.history = [
+        { role: 'user', type: 'message', content: 'first tool turn' },
+        { type: 'function_call', callId: firstToolCallId, name: 'shell', arguments: '{"command":"echo first"}' },
+        { type: 'function_call_output', callId: firstToolCallId, output: 'first' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'First done' }],
+        },
+        { role: 'user', type: 'message', content: 'retry second turn' },
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Retry done' }],
+        },
+    ];
+    let callCount = 0;
+    const mockClient = {
+        getProvider() {
+            return 'openai';
+        },
+        clearConversations() { },
+        async startStream(input) {
+            callCount++;
+            if (callCount === 1)
+                return stream1;
+            if (callCount === 2)
+                return stream2;
+            retryInput = input;
+            return retryStream;
+        },
+    };
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { session, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of session.run('first tool turn')) {
+    }
+    for await (const _ of session.run('second tool turn')) {
+    }
+    stateFacade.undoLastUserTurn();
+    const stateAfterUndo = stateFacade.exportState();
+    t.deepEqual(stateAfterUndo.toolLedger.map((entry) => entry.callId), [firstToolCallId], 'undo should retain tool ledger entries for still-retained earlier turns');
+    for await (const _ of session.run('retry second turn')) {
+    }
+    t.true(Array.isArray(retryInput), 'retry should send full history');
+    const retryCallIds = retryInput
+        .filter((item) => item.callId || item.call_id)
+        .map((item) => item.callId || item.call_id);
+    t.true(retryCallIds.includes(firstToolCallId), 'retry should keep earlier retained tool call IDs');
+    t.false(retryCallIds.includes(secondToolCallId), 'retry must drop tool call IDs from the undone turn');
+});
+//# sourceMappingURL=conversation-session.stream.test.js.map