@qduc/term2 0.7.2 → 0.8.0

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

@@ -0,0 +1,2150 @@
+import { it, expect } from 'vitest';
+import { ModelBehaviorError } from '@openai/agents';
+import { createConversationSession } from './session-composition.js';
+import { MockStream } from '../test-helpers/mock-stream.js';
+const createMockAgentClient = (overrides = {}) => ({
+    startStream: async () => new MockStream([]),
+    continueRunStream: async () => new MockStream([]),
+    abort: () => { },
+    setModel: () => { },
+    addToolInterceptor: () => () => { },
+    chat: async () => '',
+    ...overrides,
+});
+const mockLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+    security: () => { },
+    setCorrelationId: () => { },
+    getCorrelationId: () => undefined,
+    clearCorrelationId: () => { },
+};
+const sessionContextService = {
+    runWithContext: (_context, fn) => fn(),
+    getContext: () => null,
+};
+const createMockSettingsService = (entries = []) => {
+    const settings = new Map(entries);
+    return { get: (key) => settings.get(key), set: () => { } };
+};
+it('run() streams ConversationEvents (text_delta → final) in order', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('hi')) {
+        emitted.push(ev);
+    }
+    expect(emitted.map((e) => e.type)).toEqual(['text_delta', 'text_delta', 'final']);
+    expect(emitted[0].delta).toBe('Hello');
+    expect(emitted[0].fullText).toBe('Hello');
+    expect(emitted[1].delta).toBe(' world');
+    expect(emitted[1].fullText).toBe('Hello world');
+    expect(emitted[2].finalText).toBe('Hello world');
+});
+it('run() warns when completed stream history already contains duplicated tool pairs', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    for await (const _ev of turnCoordinator.start('hi')) {
+        // consume stream
+    }
+    const warning = warnings.find((entry) => entry.meta?.eventType === 'conversation.stream_history.replayed_tools');
+    expect(warning).toBeTruthy();
+    expect(warning.meta.phase).toBe('post_stream');
+    expect(warning.meta.source).toBe('startStream');
+    expect(warning.meta.historyDuplicatePairs).toBe(1);
+    expect(warning.meta.newItemsDuplicatePairs).toBe(1);
+    expect(warning.meta.stateGeneratedItemsDuplicatePairs).toBe(1);
+    expect('output' in warning.meta).toBe(false);
+});
+it('run() retries streamed recoverable errors without committing failed stream history', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('retry me')) {
+        emitted.push(ev);
+    }
+    expect(emitted.map((event) => event.type)).toEqual(['text_delta', 'retry', 'text_delta', 'final']);
+    expect(calls.length).toBe(2);
+    expect(calls[0].length).toBe(1);
+    expect(calls[1]).toEqual([{ role: 'user', type: 'message', content: 'retry me' }]);
+});
+it('run() does not retry recoverable errors from a fresh start when disabled', async () => {
+    let calls = 0;
+    const mockClient = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    const emitted = [];
+    await expect(async () => {
+        for await (const ev of turnCoordinator.start('retry me')) {
+            emitted.push(ev);
+        }
+    }).rejects.toThrow();
+    expect(calls).toBe(1);
+    expect(emitted.some((event) => event.type === 'retry')).toBe(false);
+    expect(emitted.find((event) => event.type === 'error')).toBeTruthy();
+});
+it('run() exports completed tool pairs from a stream that later fails', async () => {
+    class FailingStream extends MockStream {
+        constructor() {
+            super([]);
+        }
+        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 = createMockAgentClient({
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream() {
+            return new FailingStream();
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator, stateFacade } = bundle;
+    await expect(async () => {
+        for await (const _ev of turnCoordinator.start('inspect')) {
+            // consume stream
+        }
+    }).rejects.toThrow();
+    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.
+    expect(state.history.length).toBe(3);
+    expect(state.toolLedger.length).toBe(2);
+    expect(state.toolLedger[0].status).toBe('completed');
+    expect(state.toolLedger[1].status).toBe('aborted');
+    expect(state.toolLedger[0].historyItems.map((item) => item.callId)).toEqual(['call-read', 'call-read']);
+});
+it('run() emits tool_recovery before error when a streamed turn fails after tool activity', async () => {
+    class FailingStream extends MockStream {
+        constructor() {
+            super([]);
+        }
+        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 = createMockAgentClient({
+        getProvider() {
+            return 'openrouter';
+        },
+        async startStream() {
+            return new FailingStream();
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator, stateFacade } = bundle;
+    const emitted = [];
+    await expect(async () => {
+        for await (const ev of turnCoordinator.start('inspect')) {
+            emitted.push(ev);
+        }
+    }).rejects.toThrow();
+    const recovery = emitted.find((event) => event.type === 'tool_recovery');
+    expect(recovery).toBeTruthy();
+    expect(recovery.recoveredCallIds).toEqual(['call-read']);
+    expect(recovery.droppedCallIds).toEqual(['call-write']);
+    expect(recovery.message.includes('Recovered 1 completed')).toBe(true);
+    expect(emitted.findIndex((event) => event.type === 'tool_recovery') <
+        emitted.findIndex((event) => event.type === 'error')).toBe(true);
+    expect(emitted.map((event) => event.type)).toEqual([
+        '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);
+    expect(types.includes('function_call')).toBe(true);
+    expect(types.includes('function_call_result') || types.includes('function_call_output')).toBe(true);
+});
+it('importState() reconciles completed ledger pairs into canonical history', () => {
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: createMockAgentClient(),
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { stateFacade } = 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();
+    expect(state.history.length).toBe(3);
+    expect(state.history[1].callId).toBe('call-read');
+    expect(state.history[2].callId).toBe('call-read');
+});
+it('run() allows a follow-up after a long non-chaining run expands full history', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    stateFacade.importState({
+        previousResponseId: null,
+        history: [{ role: 'user', type: 'message', content: 'seed' }],
+    });
+    const first = [];
+    for await (const ev of turnCoordinator.start('first')) {
+        first.push(ev);
+    }
+    const second = [];
+    for await (const ev of turnCoordinator.start('second')) {
+        second.push(ev);
+    }
+    expect(calls.length).toBe(2);
+    expect(calls[0].length).toBe(2);
+    expect(calls[1].length > 212).toBe(true);
+    expect(second.map((event) => event.type)).toEqual(['text_delta', 'final']);
+});
+it('sendMessage() allows a follow-up after a long non-chaining run expands full history', async () => {
+    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 = createMockAgentClient({
+        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 { terminalAdapter, stateFacade } = bundle;
+    stateFacade.importState({
+        previousResponseId: null,
+        history: [{ role: 'user', type: 'message', content: 'seed' }],
+    });
+    await terminalAdapter.sendMessage('first');
+    const second = await terminalAdapter.sendMessage('second');
+    expect(second.type).toBe('response');
+    expect(calls.length).toBe(2);
+    expect(calls[1].length > 212).toBe(true);
+});
+it('continue() streams events after approval decision', async () => {
+    const interruption = {
+        name: 'bash',
+        agent: { name: 'CLI Agent' },
+        arguments: JSON.stringify({ command: 'echo hi' }),
+        callId: 'call-xyz',
+    };
+    const initialStream = new MockStream([]);
+    initialStream.interruptions = [interruption];
+    const approveCalls = [];
+    const rejectCalls = [];
+    initialStream.state = {
+        approveCalls,
+        rejectCalls,
+        approve(arg) {
+            approveCalls.push(arg);
+        },
+        reject(arg) {
+            rejectCalls.push(arg);
+        },
+    };
+    const continuationStream = new MockStream([{ type: 'response.output_text.delta', delta: 'Approved run' }]);
+    continuationStream.finalOutput = 'Approved run';
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream(state) {
+            expect(state).toBe(initialStream.state);
+            return continuationStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const first = [];
+    for await (const ev of turnCoordinator.start('run command')) {
+        first.push(ev);
+    }
+    expect(first.length).toBe(1);
+    expect(first[0].type).toBe('approval_required');
+    expect(first[0].approval.callId).toBe('call-xyz');
+    const cont = [];
+    for await (const ev of turnCoordinator.continueAfterApproval({ answer: 'y' })) {
+        cont.push(ev);
+    }
+    expect(cont.map((e) => e.type)).toEqual(['tool_started', 'text_delta', 'final']);
+    expect(cont[0].type).toBe('tool_started');
+    expect(cont[0].toolCallId).toBe('call-xyz');
+    expect(cont[0].toolName).toBe('bash');
+    expect(cont[1].delta).toBe('Approved run');
+    expect(cont[2].finalText).toBe('Approved run');
+});
+it('run() retries malformed tool-call interruption before surfacing approval', async () => {
+    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 = createMockAgentClient({
+        getProvider() {
+            return 'openai';
+        },
+        async startStream() {
+            startCalls++;
+            return startCalls === 1 ? malformedStream : successStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('run command')) {
+        emitted.push(ev);
+    }
+    expect(startCalls).toBe(2);
+    expect(emitted.map((event) => event.type)).toEqual(['retry', 'text_delta', 'final']);
+    expect(emitted[0].retryType).toBe('parsing_error');
+    expect(emitted[emitted.length - 1].finalText).toBe('Recovered');
+});
+it('sendMessage() preserves callId on approval_required terminal result', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('run command');
+    expect(result.type).toBe('approval_required');
+    if (result.type !== 'approval_required') {
+        expect(true).toBe(false);
+        return;
+    }
+    expect(result.approval.callId).toBe('call-preserve-1');
+});
+it('handleApprovalDecision() preserves callId on subsequent approval_required terminal result', async () => {
+    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];
+    const approveCalls = [];
+    initialStream.state = {
+        approveCalls,
+        approve(arg) {
+            approveCalls.push(arg);
+        },
+        reject() { },
+    };
+    const continuationStream = new MockStream([]);
+    continuationStream.interruptions = [secondInterruption];
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const first = await terminalAdapter.sendMessage('run command');
+    expect(first.type).toBe('approval_required');
+    if (first.type !== 'approval_required') {
+        expect(true).toBe(false);
+        return;
+    }
+    expect(first.approval.callId).toBe('call-first');
+    const second = await terminalAdapter.handleApprovalDecision('y');
+    expect(second).toBeTruthy();
+    if (second?.type !== 'approval_required') {
+        expect(true).toBe(false);
+        return;
+    }
+    expect(second.approval.callId).toBe('call-second');
+});
+it('run() sends text for OpenAI provider (server-side state)', async () => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Response' }]);
+    stream.finalOutput = 'Response';
+    let receivedInput;
+    const mockClient = createMockAgentClient({
+        async startStream(input) {
+            receivedInput = input;
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('Hello')) {
+        emitted.push(ev);
+    }
+    // OpenAI should receive just the text string (no getProvider means default 'openai')
+    expect(typeof receivedInput).toBe('string');
+    expect(receivedInput).toBe('Hello');
+    expect(emitted[emitted.length - 1].type).toBe('final');
+});
+it('run() sends full history for non-OpenAI providers (client-side state)', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('Hello')) {
+        emitted.push(ev);
+    }
+    // Non-OpenAI providers should receive full history array
+    expect(Array.isArray(receivedInput)).toBe(true);
+    expect(receivedInput.length).toBe(1); // Initial user message
+    expect(receivedInput[0].role).toBe('user');
+    expect(receivedInput[0].content).toBe('Hello');
+    expect(emitted[emitted.length - 1].type).toBe('final');
+});
+it('run() preserves assistant text prefix when SDK full-history reconstruction strips it', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    for await (const _ of turnCoordinator.start('Investigate cache issue')) {
+        // consume events
+    }
+    for await (const _ of turnCoordinator.start('Continue after max turns')) {
+        // consume events
+    }
+    const secondInput = calls[1];
+    expect(Array.isArray(secondInput)).toBe(true);
+    expect(secondInput.slice(0, 3)).toEqual([
+        { 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' },
+    ]);
+});
+it('run() sends full history for openai-compatible providers', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    // First message
+    for await (const _ of turnCoordinator.start('First message')) {
+        // consume events
+    }
+    // OpenAI-compatible provider should receive full history array
+    expect(Array.isArray(firstInput)).toBe(true);
+    expect(firstInput.length).toBe(1);
+    expect(firstInput[0].content).toBe('First message');
+    // Second message should contain both previous and new message
+    for await (const _ of turnCoordinator.start('Second message')) {
+        // consume events
+    }
+    expect(Array.isArray(secondInput)).toBe(true);
+    expect(secondInput.length >= 2).toBe(true);
+});
+it('run() chains follow-up turns for Codex provider over websocket', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator } = bundle;
+    for await (const _ of turnCoordinator.start('First message')) {
+        // consume events
+    }
+    for await (const _ of turnCoordinator.start('Second message')) {
+        // consume events
+    }
+    const firstCodexCall = calls[0];
+    expect(typeof firstCodexCall.input, 'Codex should send only the first user message on turn 1').toBe('string');
+    expect(firstCodexCall.opts.previousResponseId).toBeFalsy();
+    const secondCodexCall = calls[1];
+    expect(typeof secondCodexCall.input, 'Codex should send only the next user message on turn 2').toBe('string');
+    expect(secondCodexCall.input).toBe('Second message');
+    expect(secondCodexCall.opts.previousResponseId, 'Codex should chain follow-up turns from turn 1').toBe('resp-codex-1');
+});
+it('sendMessage() returns usage from final event', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    expect(result.type).toBe('response');
+    expect(result.usage).toEqual({
+        prompt_tokens: 11,
+        completion_tokens: 7,
+        total_tokens: 18,
+    });
+});
+it('handleApprovalDecision() returns usage from final event', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return initialStream;
+        },
+        async continueRunStream() {
+            return continuationStream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const approvalResult = await terminalAdapter.sendMessage('run command');
+    expect(approvalResult.type).toBe('approval_required');
+    const finalResult = await terminalAdapter.handleApprovalDecision('y');
+    expect(finalResult.type).toBe('response');
+    expect(finalResult.usage).toEqual({
+        prompt_tokens: 21,
+        completion_tokens: 9,
+        total_tokens: 30,
+    });
+});
+it('sendMessage() logs usage handoff at DEBUG level', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    await terminalAdapter.sendMessage('Hello');
+    const hasUsageReturnLog = debugLogs.some((log) => log.message === 'sendMessage returning response' &&
+        log.meta?.hasUsage === true);
+    expect(hasUsageReturnLog).toBe(true);
+});
+it('logs diagnostics when usage is missing in stream completion', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    await terminalAdapter.sendMessage('Hello');
+    const missingUsageLog = debugLogs.find((log) => log.message === 'No usage found in stream completion');
+    expect(missingUsageLog).toBeTruthy();
+    expect(Array.isArray(missingUsageLog.meta?.completedResultKeys)).toBe(true);
+});
+it('sendMessage() extracts usage from stream.rawResponses when completed is void', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    expect(result.type).toBe('response');
+    expect(result.usage).toEqual({
+        prompt_tokens: 13,
+        completion_tokens: 8,
+        total_tokens: 21,
+    });
+});
+it('sendMessage() preserves cache usage from streaming events when final usage omits it', async () => {
+    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);
+    stream.completed = Promise.resolve({
+        usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+    });
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { terminalAdapter } = bundle;
+    const result = await terminalAdapter.sendMessage('Hello');
+    expect(result.type).toBe('response');
+    expect(result.usage).toEqual({
+        prompt_tokens: 100,
+        completion_tokens: 20,
+        total_tokens: 120,
+        cache_read_tokens: 60,
+    });
+});
+it('run() emits usage_update when usage is nested in event.data (raw_model_stream_event)', async () => {
+    // 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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    expect(usageEvents.length >= 1).toBe(true);
+    expect(usageEvents[0].usage.prompt_tokens).toBe(50);
+    expect(usageEvents[0].usage.completion_tokens).toBe(25);
+    expect(usageEvents[0].usage.total_tokens).toBe(75);
+});
+it('run() emits usage_update when raw model stream usage is nested in event.data.event', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    expect(usageEvents.length >= 1).toBe(true);
+    expect(usageEvents[0].usage.prompt_tokens).toBe(8);
+    expect(usageEvents[0].usage.completion_tokens).toBe(3);
+    expect(usageEvents[0].usage.total_tokens).toBe(11);
+});
+it('run() emits usage_update when usage is at top level of event', async () => {
+    // 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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('hi')) {
+        emitted.push(ev);
+    }
+    const usageEvents = emitted.filter((e) => e.type === 'usage_update');
+    expect(usageEvents.length >= 1).toBe(true);
+    expect(usageEvents[0].usage.prompt_tokens).toBe(100);
+    expect(usageEvents[0].usage.completion_tokens).toBe(50);
+    expect(usageEvents[0].usage.total_tokens).toBe(150);
+});
+it('undoLastUserTurn() returns { text, imageCount: 0 } after a completed run', async () => {
+    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 = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+        getProvider() {
+            return 'openrouter';
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator, stateFacade } = bundle;
+    for await (const _ of turnCoordinator.start('hello')) {
+        // consume
+    }
+    const result = stateFacade.undoLastUserTurn();
+    expect(result).toEqual({ text: 'hello', imageCount: 0 });
+});
+it('undoLastUserTurn() returns null when no genuine user turn exists', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return new MockStream([]);
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { stateFacade } = bundle;
+    const result = stateFacade.undoLastUserTurn();
+    expect(result).toBe(null);
+});
+it('generation guard: gated run store write is skipped after undoLastUserTurn', async () => {
+    // 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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    // (a) Run msg1 to completion — store now has msg1 + Reply1.
+    for await (const _ of turnCoordinator.start('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 turnCoordinator.start('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();
+    expect(undone).toMatchObject({ text: 'msg2' });
+    // (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 turnCoordinator.start('msg3')) {
+        // consume
+    }
+    // The input to startStream for msg3 must contain msg1 but NOT msg2.
+    expect(Array.isArray(msg3Input), 'msg3 should receive history array').toBe(true);
+    const contents = msg3Input.map((item) => item.content);
+    expect(contents.includes('msg1'), 'history should contain msg1').toBe(true);
+    expect(contents.includes('msg2'), 'history must NOT contain msg2 (generation guard worked)').toBe(false);
+});
+it('run() throws AbortError when the stream is cancelled/aborted', async () => {
+    const stream = new MockStream([]);
+    stream.cancelled = true;
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            return stream;
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    await expect(async () => {
+        for await (const _ of turnCoordinator.start('hi')) {
+            void _;
+        }
+    }).rejects.toThrow();
+});
+it('run() sends full history after undo on a chaining provider (Responses API)', async () => {
+    // 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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    // Turn 1: chaining provider sends just the text string
+    for await (const _ of turnCoordinator.start('First message')) {
+    }
+    const firstChainCall = calls[0];
+    expect(typeof firstChainCall.input).toBe('string'); // was: t.is(typeof firstChainCall.input, 'string', 'Turn 1: chaining sends just the text')
+    expect(firstChainCall.opts.previousResponseId).toBeFalsy();
+    // Turn 2: chaining provider uses previousResponseId from turn 1
+    for await (const _ of turnCoordinator.start('Second message')) {
+    }
+    const secondChainCall = calls[1];
+    expect(typeof secondChainCall.input).toBe('string'); // was: t.is(typeof secondChainCall.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 turnCoordinator.start('Retry message')) {
+    }
+    const thirdCall = calls[2];
+    expect(Array.isArray(thirdCall.input), 'Turn after undo must send full history array').toBe(true);
+    expect(thirdCall.input.length >= 2, 'Full history includes prior turns').toBe(true);
+    expect(thirdCall.opts.previousResponseId, 'No previousResponseId after undo').toBeFalsy();
+});
+it('run() resyncs full history after resume before returning to chaining provider', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = 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 turnCoordinator.start('Resume follow-up')) {
+    }
+    const firstResumeCall = calls[0];
+    expect(Array.isArray(firstResumeCall.input), 'First resumed turn must resend full history').toBe(true);
+    expect(firstResumeCall.opts.previousResponseId, 'First resumed turn must not use persisted previousResponseId').toBeFalsy();
+    expect(firstResumeCall.input.map((item) => item.content)).toEqual([
+        'Earlier message',
+        [{ type: 'output_text', text: 'Earlier reply' }],
+        'Resume follow-up',
+    ]);
+    for await (const _ of turnCoordinator.start('Second follow-up')) {
+    }
+    const secondResumeCall = calls[1];
+    expect(secondResumeCall.input).toBe('Second follow-up'); // was: t.is(secondResumeCall.input, 'Second follow-up', 'Second resumed turn should return to delta chaining')
+    expect(secondResumeCall.opts.previousResponseId).toBe('resp-resynced');
+});
+it('run() ignores a stale completion after importState() bumps generation', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    const staleEvents = [];
+    const staleRun = (async () => {
+        for await (const event of turnCoordinator.start('stale request')) {
+            staleEvents.push(event);
+        }
+    })();
+    await Promise.resolve();
+    stateFacade.importState({
+        history: [],
+        previousResponseId: null,
+        toolLedger: [],
+        updatedAt: new Date().toISOString(),
+    });
+    releaseGate();
+    await staleRun;
+    expect(staleEvents).toEqual([]);
+    expect(stateFacade.exportState().history).toEqual([]);
+    for await (const _ of turnCoordinator.start('fresh request')) {
+        // consume
+    }
+    const freshCall = calls[1];
+    expect(freshCall.input).toBe('fresh request');
+    expect(freshCall.opts.previousResponseId).toBeFalsy();
+});
+it('run() with image attachment does not throw when supportsChaining is true', async () => {
+    const stream = new MockStream([{ type: 'response.output_text.delta', delta: 'Reply' }]);
+    stream.finalOutput = 'Reply';
+    let receivedInput;
+    const mockClient = createMockAgentClient({
+        async startStream(input) {
+            receivedInput = input;
+            return stream;
+        },
+        getProvider() {
+            return 'openai';
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = 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 turnCoordinator.start(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.
+    expect(Array.isArray(receivedInput), 'Input should be wrapped in an array').toBe(true);
+    expect(receivedInput.length).toBe(1);
+    const firstReceived = receivedInput[0];
+    expect(firstReceived.role).toBe('user');
+    const receivedContent = firstReceived.content;
+    expect(receivedContent[0].type).toBe('input_text');
+    expect(receivedContent[1].type).toBe('input_image');
+});
+it('previewLargeUncachedInput() does not mutate history or consume pending mode notice', () => {
+    const mockClient = createMockAgentClient({
+        getProvider() {
+            return 'codex';
+        },
+    });
+    const settingsService = createMockSettingsService([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+        ['app.planMode', true],
+    ]);
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { stateFacade } = bundle;
+    stateFacade.queueModeNotice('Plan mode enabled');
+    const before = stateFacade.exportState();
+    const decision = stateFacade.previewLargeUncachedInput('hello', 1_000);
+    expect(decision.action).toBe('allow');
+    expect(stateFacade.exportState()).toEqual(before);
+});
+it('previewLargeUncachedInput() estimates from outgoing input instead of accepting accumulated session usage overrides', () => {
+    const mockClient = createMockAgentClient({
+        getProvider() {
+            return 'codex';
+        },
+    });
+    const settingsService = createMockSettingsService([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+    ]);
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { stateFacade } = bundle;
+    const large = 'x'.repeat(64_000 * 4);
+    const decision = stateFacade.previewLargeUncachedInput(large, 1_000);
+    expect(decision.action).toBe('allow');
+    expect(decision.estimatedTokens >= 64_000).toBe(true);
+});
+it('sendMessage() records successful large guard state after provider request completion', async () => {
+    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 = createMockAgentClient({
+        getProvider() {
+            return 'codex';
+        },
+        async startStream() {
+            return firstStream;
+        },
+    });
+    const settingsService = createMockSettingsService([
+        ['agent.model', 'gpt-5'],
+        ['agent.provider', 'codex'],
+        ['agent.reasoningEffort', 'medium'],
+    ]);
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, settingsService, sessionContextService },
+    });
+    const { terminalAdapter, stateFacade } = bundle;
+    const large = 'x'.repeat(64_000 * 4);
+    expect(stateFacade.previewLargeUncachedInput(large, 1_000).action).toBe('allow');
+    await terminalAdapter.sendMessage(large);
+    const decision = stateFacade.previewLargeUncachedInput(large, Date.now() + 5 * 60 * 1_000 + 1);
+    expect(decision.action).toBe('warn');
+    expect(decision.reasons.includes('idle_timeout')).toBe(true);
+});
+it('run() yields an error event carrying droppedUserMessage when startStream fails pre-stream', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            throw new Error('upstream 500');
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator, stateFacade } = bundle;
+    const emitted = [];
+    let thrown = null;
+    try {
+        for await (const ev of turnCoordinator.start('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');
+    expect(errorEvent, 'should emit an error event').toBeTruthy();
+    if (!errorEvent) {
+        throw new Error('expected an error event');
+        return;
+    }
+    expect(errorEvent.droppedUserMessage, 'error event should carry droppedUserMessage').toBeTruthy();
+    expect(errorEvent.droppedUserMessage.text).toBe('hello');
+    expect(errorEvent.droppedUserMessage.imageCount).toBe(0);
+    // And the store should have rolled back the user turn so /undo state is clean.
+    expect(stateFacade.listUserTurns().length).toBe(0);
+    expect(thrown).toBeTruthy();
+});
+it('run() omits droppedUserMessage when no user turn was added (skipUserMessage)', async () => {
+    const mockClient = createMockAgentClient({
+        async startStream() {
+            throw new Error('upstream 500');
+        },
+    });
+    const bundle = createConversationSession({
+        sessionId: 's1',
+        agentClient: mockClient,
+        deps: { logger: mockLogger, sessionContextService },
+    });
+    const { turnCoordinator } = bundle;
+    const emitted = [];
+    try {
+        for await (const ev of turnCoordinator.start('hello', { skipUserMessage: true })) {
+            emitted.push(ev);
+        }
+    }
+    catch {
+        // expected
+    }
+    const errorEvent = emitted.find((e) => e.type === 'error');
+    expect(errorEvent).toBeTruthy();
+    if (!errorEvent) {
+        throw new Error('expected an error event');
+        return;
+    }
+    expect(errorEvent.droppedUserMessage).toBe(undefined);
+});
+it('run() emits user_message_consumed_for_abort when an aborted approval is being resolved', async () => {
+    // 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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade, 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 turnCoordinator.start('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');
+    expect(idx >= 0).toBe(true);
+    // The store must not have a genuine user turn for this input.
+    expect(stateFacade.listUserTurns().length).toBe(0);
+});
+it('switchProvider() clears provider continuity but preserves transcript history', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, terminalAdapter, stateFacade, runtimeController, approvalState } = bundle;
+    for await (const _ of turnCoordinator.start('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');
+    expect(await terminalAdapter.handleApprovalDecision('y'), 'pending approval should be cleared on provider switch').toBe(null);
+    const emitted = [];
+    for await (const ev of turnCoordinator.start('Second message')) {
+        emitted.push(ev);
+    }
+    expect(clearConversationsCalls).toBe(1);
+    expect(provider).toBe('openrouter');
+    expect(emitted.some((event) => event.type === 'user_message_consumed_for_abort')).toBe(false);
+    const secondCall = calls[1];
+    expect(Array.isArray(secondCall.input)).toBe(true);
+    expect(secondCall.input.length >= 2).toBe(true);
+    expect(secondCall.opts.previousResponseId).toBeFalsy();
+    expect(stateFacade.listUserTurns().map((turn) => turn.text)).toEqual(['First message', 'Second message']);
+});
+it('setModel() clears provider continuity and forces full-history replay on the next turn', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, runtimeController } = bundle;
+    for await (const _ of turnCoordinator.start('First message')) {
+    }
+    runtimeController.setModel('gpt-next');
+    for await (const _ of turnCoordinator.start('Second message')) {
+    }
+    expect(models).toEqual(['gpt-next']);
+    const secondCall = calls[1];
+    expect(Array.isArray(secondCall.input)).toBe(true);
+    expect(secondCall.opts.previousResponseId).toBeFalsy();
+});
+it('undoLastUserTurn() clears tool ledger so stale tool calls are not re-injected on retry', async () => {
+    // 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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    // Run turn 1 to completion — tool ledger now has the tool call entry.
+    for await (const _ of turnCoordinator.start('run echo hello')) {
+        // consume
+    }
+    // Verify ledger has entries before undo.
+    const stateBefore = stateFacade.exportState();
+    expect(stateBefore.toolLedger.length > 0).toBe(true);
+    // Undo the turn.
+    stateFacade.undoLastUserTurn();
+    // Verify ledger is cleared after undo.
+    const stateAfter = stateFacade.exportState();
+    expect(stateAfter.toolLedger.length, 'tool ledger must be empty after undo').toBe(0);
+    // Retry the same message — the model must NOT see the old tool call/result pair.
+    for await (const _ of turnCoordinator.start('run echo hello')) {
+        // consume
+    }
+    expect(Array.isArray(retryInput)).toBe(true);
+    const callIds = retryInput
+        .filter((item) => item.callId || item.call_id)
+        .map((item) => item.callId || item.call_id);
+    expect(callIds.includes(toolCallId)).toBe(false);
+});
+it('undoLastUserTurn() preserves earlier tool ledger entries that still belong to retained turns', async () => {
+    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 = createMockAgentClient({
+        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 { turnCoordinator, stateFacade } = bundle;
+    for await (const _ of turnCoordinator.start('first tool turn')) {
+    }
+    for await (const _ of turnCoordinator.start('second tool turn')) {
+    }
+    stateFacade.undoLastUserTurn();
+    const stateAfterUndo = stateFacade.exportState();
+    expect(stateAfterUndo.toolLedger.map((entry) => entry.callId), 'undo should retain tool ledger entries for still-retained earlier turns').toEqual([firstToolCallId]);
+    for await (const _ of turnCoordinator.start('retry second turn')) {
+    }
+    expect(Array.isArray(retryInput)).toBe(true);
+    const retryCallIds = retryInput
+        .filter((item) => item.callId || item.call_id)
+        .map((item) => item.callId || item.call_id);
+    expect(retryCallIds.includes(firstToolCallId)).toBe(true);
+    expect(retryCallIds.includes(secondToolCallId)).toBe(false);
+});
+//# sourceMappingURL=conversation-session.stream.test.js.map