@qduc/term2 0.6.1 → 0.7.1

package/dist/services/conversation-session.js

@@ -3,17 +3,50 @@ import { decideRetry, isTransientRetryableError, MAX_HALLUCINATION_RETRIES, MAX_
 import { getProvider } from '../providers/index.js';
 import { ApprovalState } from './approval-state.js';
 import { collectTerminalResult } from './terminal-result-collector.js';
-import { getMethod } from './interruption-info.js';
+import { getMethod, getCallIdFromObject } from './interruption-info.js';
 import { createStreamAccumulator, processStreamEvents } from './stream-event-processor.js';
 import { ShellAutoApprovalResolver } from './shell-auto-approval-resolver.js';
 import { ApprovalFlowCoordinator } from './approval-flow-coordinator.js';
 import { buildConversationResult, toTerminalEvent } from './conversation-result-builder.js';
 import { normalizeUserTurn } from '../types/user-turn.js';
-import { InputSurgeGuard } from './input-surge-guard.js';
+import { collectDuplicateToolCallResultPairs, InputSurgeGuard } from './input-surge-guard.js';
+import { LargeUncachedInputGuard } from './large-uncached-input-guard.js';
+import { reconcileHistoryWithToolLedger, ToolExecutionLedger, callIdOf, toolNameOf, outputOf, } from './tool-execution-ledger.js';
+import { describeError } from '../utils/error-helpers.js';
 const supportsConversationChaining = (providerId) => {
     const providerDef = getProvider(providerId);
     return providerDef?.capabilities?.supportsConversationChaining ?? false;
 };
+const asArray = (value) => (Array.isArray(value) ? value : []);
+const warnIfStreamHistoryReplayedTools = ({ logger, sessionId, source, stream, }) => {
+    const streamRecord = stream;
+    const history = asArray(streamRecord.history);
+    const newItems = asArray(streamRecord.newItems);
+    const stateGeneratedItems = asArray(streamRecord.state?._generatedItems);
+    const historyDuplicates = collectDuplicateToolCallResultPairs(history);
+    const newItemsDuplicates = collectDuplicateToolCallResultPairs(newItems);
+    const stateGeneratedItemsDuplicates = collectDuplicateToolCallResultPairs(stateGeneratedItems);
+    if (historyDuplicates.pairs === 0 && newItemsDuplicates.pairs === 0 && stateGeneratedItemsDuplicates.pairs === 0) {
+        return;
+    }
+    logger.warn('Completed stream history contains replayed tool call/result pairs', {
+        eventType: 'conversation.stream_history.replayed_tools',
+        category: 'provider',
+        phase: 'post_stream',
+        sessionId,
+        traceId: logger.getCorrelationId(),
+        source,
+        historyLength: history.length,
+        newItemsLength: newItems.length,
+        stateGeneratedItemsLength: stateGeneratedItems.length,
+        historyDuplicatePairs: historyDuplicates.pairs,
+        historyMaxCopies: historyDuplicates.maxCopies,
+        newItemsDuplicatePairs: newItemsDuplicates.pairs,
+        newItemsMaxCopies: newItemsDuplicates.maxCopies,
+        stateGeneratedItemsDuplicatePairs: stateGeneratedItemsDuplicates.pairs,
+        stateGeneratedItemsMaxCopies: stateGeneratedItemsDuplicates.maxCopies,
+    });
+};
 export class ConversationSession {
     id;
     startedAt;
@@ -24,12 +57,19 @@ export class ConversationSession {
     approvalState = new ApprovalState();
     toolCallArgumentsById = new Map();
     emittedInvalidToolCallPackets = new Set();
+    emittedToolStartedCallIds = new Set();
     shellAutoApproval;
     approvalFlow;
     inputSurgeGuard = new InputSurgeGuard();
+    largeUncachedInputGuard = new LargeUncachedInputGuard();
+    toolLedger = new ToolExecutionLedger();
     generation = 0;
+    #inputSurgeKind = 'delta';
+    currentPersistedTurnItems = [];
+    currentReasoningBuffer = '';
+    currentAssistantTextBuffer = '';
     settingsService;
-    pendingModeNotice = null;
+    logSink = null;
     constructor(id, { agentClient, deps, sessionStartedAt, }) {
         this.id = id;
         this.startedAt = sessionStartedAt ?? new Date().toISOString();
@@ -63,6 +103,61 @@ export class ConversationSession {
             return 'mentor';
         return 'standard';
     }
+    #getModelForGuard() {
+        return this.settingsService?.get('agent.model') ?? null;
+    }
+    #getReasoningEffortForGuard() {
+        return this.settingsService?.get('agent.reasoningEffort') ?? null;
+    }
+    #getProviderForGuard() {
+        const getProvider = getMethod(this.agentClient, 'getProvider');
+        return getProvider
+            ? getProvider.call(this.agentClient)
+            : this.settingsService?.get('agent.provider') ?? null;
+    }
+    #makeUserInputItem(turn) {
+        const images = turn.images ?? [];
+        if (images.length === 0) {
+            return { role: 'user', type: 'message', content: turn.text ?? '' };
+        }
+        const content = [];
+        if (turn.text) {
+            content.push({ type: 'input_text', text: turn.text });
+        }
+        for (const image of images) {
+            content.push({
+                type: 'input_image',
+                image: `data:${image.mimeType};base64,${image.data}`,
+                detail: 'auto',
+            });
+        }
+        return { role: 'user', type: 'message', content };
+    }
+    #buildOutgoingInput(turn, { includeTurn }) {
+        const provider = this.#getProviderForGuard() ?? 'openai';
+        const supportsChaining = supportsConversationChaining(provider);
+        const history = this.#getCanonicalHistory();
+        const outgoingHistory = includeTurn ? [...history, this.#makeUserInputItem(turn)] : history;
+        const useChaining = supportsChaining && (!!this.previousResponseId || outgoingHistory.length <= 1);
+        const latestInput = outgoingHistory[outgoingHistory.length - 1] ?? turn.text;
+        const chainedInput = turn.images?.length ? latestInput : turn.text;
+        return {
+            streamInput: useChaining ? (typeof chainedInput === 'string' ? chainedInput : [chainedInput]) : outgoingHistory,
+            inputSurgeKind: useChaining ? 'delta' : 'full_history',
+        };
+    }
+    previewLargeUncachedInput(input, now = Date.now()) {
+        const turn = normalizeUserTurn(input);
+        const { streamInput } = this.#buildOutgoingInput(turn, { includeTurn: true });
+        return this.largeUncachedInputGuard.inspect({
+            input: streamInput,
+            now,
+            provider: this.#getProviderForGuard(),
+            model: this.#getModelForGuard(),
+            reasoningEffort: this.#getReasoningEffortForGuard(),
+            mode: this.#getTrafficMode(),
+        });
+    }
     #getFirstUserMessagePreview(currentTurn) {
         const [firstTurn] = this.conversationStore.listUserTurns();
         return firstTurn?.text ?? currentTurn ?? '';
@@ -89,8 +184,13 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
+        this.toolLedger = new ToolExecutionLedger();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.reset();
+        this.#inputSurgeKind = 'delta';
+        this.#resetPersistedTurnState();
         const clearConversations = getMethod(this.agentClient, 'clearConversations');
         clearConversations?.call(this.agentClient);
     }
@@ -103,8 +203,13 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markUndoOrRewind();
+        this.#inputSurgeKind = 'delta';
+        this.#resetPersistedTurnState();
+        this.#log({ type: 'undo', removedUserTurns: 1, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     listUserTurns() {
@@ -119,8 +224,13 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markUndoOrRewind();
+        this.#inputSurgeKind = 'delta';
+        this.#resetPersistedTurnState();
+        this.#log({ type: 'undo', removedUserTurns: n, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     setModel(model) {
@@ -135,52 +245,292 @@ export class ConversationSession {
         setTemperature?.call(this.agentClient, temperature);
     }
     setProvider(provider) {
+        this.generation++;
+        this.previousResponseId = null;
+        this.approvalState.clearPending();
+        this.approvalState.consumeAborted();
+        this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
+        this.shellAutoApproval.clearCache();
+        this.inputSurgeGuard.reset();
+        const clearConversations = getMethod(this.agentClient, 'clearConversations');
+        clearConversations?.call(this.agentClient);
         const setProvider = getMethod(this.agentClient, 'setProvider');
         setProvider?.call(this.agentClient, provider);
     }
+    switchProvider(provider) {
+        this.setProvider(provider);
+    }
     setRetryCallback(callback) {
         if (typeof this.agentClient.setRetryCallback === 'function') {
             this.agentClient.setRetryCallback(callback);
         }
     }
+    setLogSink(sink) {
+        this.logSink = sink;
+    }
+    getCurrentSnapshot() {
+        const getProvider = getMethod(this.agentClient, 'getProvider');
+        const provider = getProvider
+            ? getProvider.call(this.agentClient)
+            : this.settingsService?.get('agent.provider');
+        const model = this.settingsService?.get('agent.model');
+        return {
+            history: this.#getCanonicalHistory(),
+            previousResponseId: this.previousResponseId,
+            toolLedger: this.toolLedger.export(),
+            ...(model ? { model } : {}),
+            ...(provider ? { provider } : {}),
+        };
+    }
+    #getCurrentAssistantTurnState() {
+        const getProvider = getMethod(this.agentClient, 'getProvider');
+        const provider = getProvider
+            ? getProvider.call(this.agentClient)
+            : this.settingsService?.get('agent.provider');
+        const model = this.settingsService?.get('agent.model');
+        return {
+            previousResponseId: this.previousResponseId,
+            ...(model ? { model } : {}),
+            ...(provider ? { provider } : {}),
+        };
+    }
+    #flushReasoningItem() {
+        if (this.currentReasoningBuffer) {
+            this.currentPersistedTurnItems.push({
+                type: 'reasoning',
+                text: this.currentReasoningBuffer,
+            });
+            this.currentReasoningBuffer = '';
+        }
+    }
+    #flushAssistantTextItem() {
+        if (this.currentAssistantTextBuffer) {
+            this.currentPersistedTurnItems.push({
+                type: 'assistant_text',
+                text: this.currentAssistantTextBuffer,
+            });
+            this.currentAssistantTextBuffer = '';
+        }
+    }
+    #recordToolCallItem(callId, toolName, args) {
+        this.#flushReasoningItem();
+        this.#flushAssistantTextItem();
+        this.currentPersistedTurnItems.push({
+            type: 'tool_call',
+            callId,
+            toolName,
+            arguments: args,
+        });
+    }
+    #recordToolResultItem(callId, toolName, status, output) {
+        this.#flushReasoningItem();
+        this.#flushAssistantTextItem();
+        this.currentPersistedTurnItems.push({
+            type: 'tool_result',
+            callId,
+            toolName,
+            status,
+            output,
+        });
+    }
+    #resetPersistedTurnState() {
+        this.currentPersistedTurnItems = [];
+        this.currentReasoningBuffer = '';
+        this.currentAssistantTextBuffer = '';
+    }
+    #log(event) {
+        if (!this.logSink)
+            return;
+        try {
+            this.logSink(event);
+        }
+        catch (err) {
+            this.logger.warn('Conversation log sink threw', {
+                eventType: 'conversation_log.sink_failed',
+                category: 'persistence',
+                errorMessage: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    #dispatchEventToLog(event) {
+        if (!this.logSink)
+            return;
+        switch (event.type) {
+            case 'text_delta':
+                if (this.currentReasoningBuffer) {
+                    this.#flushReasoningItem();
+                }
+                this.currentAssistantTextBuffer += event.delta;
+                return;
+            case 'reasoning_delta':
+                if (this.currentAssistantTextBuffer) {
+                    this.#flushAssistantTextItem();
+                }
+                this.currentReasoningBuffer += event.delta;
+                return;
+            case 'tool_started':
+                this.#recordToolCallItem(event.toolCallId, event.toolName, event.arguments);
+                this.#log({
+                    type: 'tool_started',
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    arguments: event.arguments,
+                });
+                return;
+            case 'command_message':
+                this.#log({ type: 'command_message', message: event.message });
+                if (event.message.callId &&
+                    event.message.toolName &&
+                    (event.message.status === 'completed' || event.message.status === 'failed')) {
+                    this.#recordToolResultItem(event.message.callId, event.message.toolName, event.message.status === 'failed' ? 'failed' : 'completed', event.message.output);
+                }
+                return;
+            case 'approval_required':
+                this.#log({
+                    type: 'approval_required',
+                    approval: {
+                        toolName: event.approval.toolName,
+                        argumentsText: event.approval.argumentsText,
+                        agentName: event.approval.agentName,
+                        ...('callId' in event.approval && event.approval.callId ? { callId: event.approval.callId } : {}),
+                    },
+                });
+                return;
+            case 'subagent_started':
+                this.#log({
+                    type: 'subagent_started',
+                    agentId: event.agentId,
+                    role: event.role,
+                    task: event.task,
+                });
+                return;
+            case 'subagent_completed':
+                this.#log({ type: 'subagent_completed', result: event.result });
+                return;
+            case 'error':
+                this.#log({
+                    type: 'error',
+                    message: event.message,
+                    ...(event.kind ? { kind: event.kind } : {}),
+                    ...(event.stack ? { stack: event.stack } : {}),
+                });
+                return;
+            case 'final': {
+                const turnState = this.#getCurrentAssistantTurnState();
+                const toolLedger = this.toolLedger.export();
+                this.#flushReasoningItem();
+                this.#flushAssistantTextItem();
+                const turnItemsToLog = event.turnItems ? [...event.turnItems] : [...this.currentPersistedTurnItems];
+                if (event.finalText && !turnItemsToLog.some((item) => item.type === 'assistant_text')) {
+                    turnItemsToLog.push({
+                        type: 'assistant_text',
+                        text: event.finalText,
+                    });
+                }
+                // Invariant check: if transcript contains tool_result, matching call IDs exist in the live tool ledger.
+                for (const item of turnItemsToLog) {
+                    if (item.type === 'tool_result') {
+                        const exists = toolLedger.some((t) => t.callId === item.callId);
+                        if (!exists) {
+                            this.logger.warn(`Invariant violation: tool_result callId ${item.callId} not found in toolLedger`);
+                        }
+                    }
+                }
+                const turn = {
+                    items: turnItemsToLog,
+                };
+                this.#log({
+                    type: 'assistant_turn',
+                    turn,
+                    ...(event.usage ? { usage: event.usage } : {}),
+                    state: turnState,
+                });
+                this.#resetPersistedTurnState();
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    #dedupeToolStarted(event) {
+        if (event.type !== 'tool_started') {
+            return event;
+        }
+        if (this.emittedToolStartedCallIds.has(event.toolCallId)) {
+            return null;
+        }
+        this.emittedToolStartedCallIds.add(event.toolCallId);
+        return event;
+    }
+    #getCanonicalHistory() {
+        return reconcileHistoryWithToolLedger(this.conversationStore.getHistory(), this.toolLedger.export())
+            .history;
+    }
     exportState() {
         return {
-            history: this.conversationStore.getHistory(),
+            history: this.#getCanonicalHistory(),
             previousResponseId: this.previousResponseId,
+            toolLedger: this.toolLedger.export(),
         };
     }
     importState(state) {
         this.conversationStore.clear();
-        for (const item of state.history) {
+        this.toolLedger.import(state.toolLedger);
+        const reconciled = reconcileHistoryWithToolLedger(state.history, state.toolLedger);
+        if (reconciled.addedCompletedPairs > 0 || reconciled.droppedIncompleteCalls > 0) {
+            this.logger.warn('Reconciled saved conversation history with tool execution ledger', {
+                eventType: 'conversation.tool_ledger.reconciled',
+                category: 'conversation',
+                phase: 'resume',
+                sessionId: this.id,
+                addedCompletedPairs: reconciled.addedCompletedPairs,
+                droppedIncompleteCalls: reconciled.droppedIncompleteCalls,
+            });
+        }
+        for (const item of reconciled.history) {
             this.conversationStore.addImportedItem(item);
         }
         this.previousResponseId = state.previousResponseId;
+        this.emittedToolStartedCallIds.clear();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markResumedSession({
+            updatedAtMs: state.updatedAt ? Date.parse(state.updatedAt) : null,
+        });
         this.generation++;
     }
     addShellContext(historyText) {
         this.conversationStore.addShellContext(historyText);
     }
-    queueModeNotice(text) {
-        this.pendingModeNotice = text;
-    }
     /**
      * Abort the current running operation
      */
     abort() {
-        this.approvalFlow.abort();
+        const pending = this.approvalFlow.getPending();
+        const callId = pending ? getCallIdFromObject(pending.interruption) : undefined;
+        if (this.approvalFlow.abort()) {
+            this.toolLedger.recordAbortedApproval('Tool execution was not approved.', 'Tool execution was not approved.', callId);
+        }
     }
     /**
      * Phase 4: stream conversation events as an async iterator.
      *
      * This is the transport-friendly primitive that can later be bridged to SSE/WebSockets.
      */
-    async *run(input, { hallucinationRetryCount = 0, flexServiceTierFallbackCount = 0, skipUserMessage = false, } = {}) {
+    async *run(input, { skipUserMessage = false, flexServiceTierFallbackCount = 0, hallucinationRetryCount = 0, transientRetryCount = 0, } = {}) {
+        if (!skipUserMessage ||
+            hallucinationRetryCount > 0 ||
+            flexServiceTierFallbackCount > 0 ||
+            transientRetryCount > 0) {
+            this.#resetPersistedTurnState();
+        }
         const gen = this.generation;
         let stream = null;
         const turn = normalizeUserTurn(input);
         const text = turn.text;
         let addedUserMessage = false;
+        const ledgerSnapshot = this.toolLedger.export();
+        this.toolLedger.beginTurn();
         try {
             this.logger.debug('Conversation stream start', {
                 eventType: 'stream.started',
@@ -196,6 +546,12 @@ export class ConversationSession {
                 this.conversationStore.addUserTurn(turn);
                 addedUserMessage = true;
             }
+            else if (abortedContext && !skipUserMessage) {
+                // The UI appended a user message for this input, but the store will consume it
+                // as fake tool output for the aborted approval rather than as a new user turn.
+                // Signal the UI to mark it so /undo skips it.
+                yield { type: 'user_message_consumed_for_abort' };
+            }
             // If there's an aborted approval, we need to resolve it first.
             // The user's message is a new input, but the agent is stuck waiting for tool output.
             if (abortedContext) {
@@ -213,17 +569,53 @@ export class ConversationSession {
                 try {
                     const continuedStream = (await this.agentClient.continueRunStream(abortedContext.state, {
                         previousResponseId: this.previousResponseId,
+                        sessionId: this.id,
                     }));
                     const acc = createStreamAccumulator();
                     acc.emittedCommandIds = new Set(abortedContext.emittedCommandIds);
-                    yield* processStreamEvents(continuedStream, acc, {
+                    for await (const event of processStreamEvents(continuedStream, acc, {
                         toolCallArgumentsById: this.toolCallArgumentsById,
                         emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                         preserveExistingToolArgs: true,
-                    }, { logger: this.logger, sessionId: this.id });
+                        onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOf(item);
+                            if (cid && this.logSink) {
+                                const entry = this.toolLedger.export().find((e) => e.callId === cid);
+                                this.#log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOf(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOf(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.logger, sessionId: this.id })) {
+                        const filtered = this.#dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
                     if (this.#isCurrentGeneration(gen)) {
                         this.previousResponseId = continuedStream.lastResponseId ?? null;
-                        this.conversationStore.updateFromResult(continuedStream);
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'abortResolution',
+                            stream: continuedStream,
+                        });
+                        const s = continuedStream;
+                        const terminal = !continuedStream.interruptions || continuedStream.interruptions.length === 0;
+                        if (terminal) {
+                            if (this.#inputSurgeKind === 'delta') {
+                                this.conversationStore.appendOutput(s.output);
+                            }
+                            else {
+                                this.conversationStore.replaceHistory(s.history);
+                            }
+                        }
                     }
                     // Check if another interruption occurred
                     if (continuedStream.interruptions && continuedStream.interruptions.length > 0) {
@@ -251,49 +643,21 @@ export class ConversationSession {
                 }
             }
             // Normal message flow
-            const getProvider = getMethod(this.agentClient, 'getProvider');
-            const provider = getProvider ? getProvider.call(this.agentClient) : 'openai';
-            const supportsChaining = supportsConversationChaining(provider);
-            const history = this.conversationStore.getHistory();
             // Use chaining mode only when the provider supports it AND either a valid
             // chain exists (previousResponseId is set) or there is no prior history to
             // resync (fresh start with just the current message). After undo the chain
             // is severed (previousResponseId = null) while prior turns remain in the
             // local store, so we fall back to full-history mode to re-establish context.
-            const useChaining = supportsChaining && (!!this.previousResponseId || history.length <= 1);
-            let streamInput;
-            if (this.pendingModeNotice) {
-                const notice = this.pendingModeNotice;
-                this.pendingModeNotice = null;
-                if (useChaining) {
-                    const latestInput = history[history.length - 1] ?? text;
-                    const chainedInput = turn.images?.length ? latestInput : text;
-                    const userItem = typeof chainedInput === 'string' ? { role: 'user', type: 'message', content: chainedInput } : chainedInput;
-                    const noticeItem = { role: 'system', type: 'message', content: notice };
-                    streamInput = [noticeItem, userItem];
-                }
-                else {
-                    // Persist the notice at the tail (append-only) rather than splicing
-                    // it before the last user turn or sending it as a one-shot item.
-                    // Mid-history insertion adds a stray ephemeral cache breakpoint (see
-                    // addCacheControlToLastTwoMessages) and a transient item makes
-                    // consecutive requests diverge at the tail — both break the
-                    // Claude/Qwen prompt cache. Appending keeps the cached prefix
-                    // byte-identical and only growing.
-                    this.conversationStore.addModeNotice(notice);
-                    streamInput = this.conversationStore.getHistory();
-                }
-            }
-            else {
-                const latestInput = history[history.length - 1] ?? text;
-                const chainedInput = turn.images?.length ? latestInput : text;
-                streamInput = useChaining ? (typeof chainedInput === 'string' ? chainedInput : [chainedInput]) : history;
-            }
-            const inputSurgeKind = useChaining ? 'delta' : 'full_history';
+            const { streamInput, inputSurgeKind } = this.#buildOutgoingInput(turn, {
+                includeTurn: false,
+            });
+            this.#inputSurgeKind = inputSurgeKind;
             const surgeDecision = this.inputSurgeGuard.inspect(streamInput, { kind: inputSurgeKind });
             if (surgeDecision.action === 'block') {
+                let droppedUserMessage;
                 if (addedUserMessage && this.#isCurrentGeneration(gen)) {
                     this.conversationStore.removeLastUserMessage();
+                    droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
                 }
                 this.logger.warn('Input surge guard blocked provider request', {
                     eventType: 'input_surge.blocked',
@@ -309,24 +673,47 @@ export class ConversationSession {
                     type: 'error',
                     kind: 'input_surge_guard',
                     message: `${surgeDecision.reason} Request blocked to prevent runaway context growth. Try /undo or /clear, or compact the conversation history.`,
+                    ...(droppedUserMessage ? { droppedUserMessage } : {}),
                 };
                 return;
             }
             stream = (await this.agentClient.startStream(streamInput, {
-                previousResponseId: this.previousResponseId,
+                previousResponseId: inputSurgeKind === 'delta' ? this.previousResponseId : null,
+                sessionId: this.id,
             }));
             const acc = createStreamAccumulator();
-            yield* processStreamEvents(stream, acc, {
+            for await (const event of processStreamEvents(stream, acc, {
                 toolCallArgumentsById: this.toolCallArgumentsById,
                 emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                 preserveExistingToolArgs: false,
-            }, { logger: this.logger, sessionId: this.id });
+                onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                onFunctionResultItem: (item) => this.toolLedger.recordFunctionResult(item),
+            }, { logger: this.logger, sessionId: this.id })) {
+                const filtered = this.#dedupeToolStarted(event);
+                if (filtered)
+                    yield filtered;
+            }
             if (this.#isCurrentGeneration(gen)) {
                 this.previousResponseId = stream.lastResponseId ?? null;
-                this.conversationStore.updateFromResult(stream);
+                warnIfStreamHistoryReplayedTools({
+                    logger: this.logger,
+                    sessionId: this.id,
+                    source: 'startStream',
+                    stream,
+                });
+                const s = stream;
+                const terminal = !stream.interruptions || stream.interruptions.length === 0;
+                if (terminal) {
+                    if (inputSurgeKind === 'delta') {
+                        this.conversationStore.appendOutput(s.output);
+                    }
+                    else {
+                        this.conversationStore.replaceHistory(s.history);
+                    }
+                }
             }
             const resolvedResult = yield* this.#buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, acc.latestUsage);
-            if (useChaining) {
+            if (inputSurgeKind === 'delta') {
                 this.inputSurgeGuard.recordSuccessfulInput(streamInput, { kind: inputSurgeKind });
             }
             else {
@@ -335,7 +722,23 @@ export class ConversationSession {
                     previousInput: streamInput,
                 });
             }
+            this.largeUncachedInputGuard.recordSuccessfulInput({
+                input: inputSurgeKind === 'delta' ? streamInput : this.conversationStore.getHistory(),
+                now: Date.now(),
+                provider: this.#getProviderForGuard(),
+                model: this.#getModelForGuard(),
+                reasoningEffort: this.#getReasoningEffortForGuard(),
+                mode: this.#getTrafficMode(),
+            });
             if (resolvedResult.type === 'approval_required') {
+                if (resolvedResult.approval.callId) {
+                    this.toolLedger.recordFunctionCall({
+                        type: 'function_call',
+                        callId: resolvedResult.approval.callId,
+                        name: resolvedResult.approval.toolName,
+                        arguments: resolvedResult.approval.argumentsText,
+                    });
+                }
                 this.logger.debug('Tool approval required', {
                     eventType: 'approval.required',
                     category: 'approval',
@@ -374,12 +777,52 @@ export class ConversationSession {
                     retryType: 'flex_service_tier',
                 };
                 getMethod(this.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.agentClient);
+                this.toolLedger.import(ledgerSnapshot);
                 yield* this.run(turn, {
                     skipUserMessage: true,
                     flexServiceTierFallbackCount: flexServiceTierFallbackCount + 1,
                 });
                 return;
             }
+            if (isTransientRetryableError(error) && transientRetryCount < MAX_TRANSIENT_RETRIES) {
+                const attempt = transientRetryCount + 1;
+                const delay = Math.min(500 * Math.pow(2, attempt - 1), 30000);
+                this.logger.warn('Transient upstream error detected, retrying turn', {
+                    eventType: 'retry.transient',
+                    category: 'retry',
+                    phase: 'retry',
+                    retryType: 'upstream',
+                    retryAttempt: attempt,
+                    attempt,
+                    maxRetries: MAX_TRANSIENT_RETRIES,
+                    sessionId: this.id,
+                    traceId: this.logger.getCorrelationId(),
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    delayMs: delay,
+                });
+                yield {
+                    type: 'retry',
+                    toolName: 'turn',
+                    attempt,
+                    maxRetries: MAX_TRANSIENT_RETRIES,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    retryType: 'upstream',
+                };
+                if (!this.#isCurrentGeneration(gen))
+                    return;
+                if (stream) {
+                    this.toolLedger.import(ledgerSnapshot);
+                }
+                else {
+                    this.conversationStore.removeLastUserMessage();
+                }
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                yield* this.run(turn, {
+                    skipUserMessage: Boolean(stream),
+                    transientRetryCount: attempt,
+                });
+                return;
+            }
             const decision = decideRetry(error, hallucinationRetryCount, Boolean(stream), streamHistoryLength);
             if (decision.kind === 'retry') {
                 this.logger.warn('Recoverable model error detected, retrying', {
@@ -399,6 +842,7 @@ export class ConversationSession {
                 if (!this.#isCurrentGeneration(gen))
                     return;
                 if (decision.hadStream && stream) {
+                    this.toolLedger.import(ledgerSnapshot);
                     if (decision.shouldInjectErrorContext) {
                         this.conversationStore.addErrorContext(decision.errorContextMessage);
                     }
@@ -409,20 +853,47 @@ export class ConversationSession {
                 yield* this.run(turn, decision.nextRunOptions);
                 return;
             }
-            yield {
-                type: 'error',
-                message: error instanceof Error ? error.message : String(error),
-            };
+            // Drop the just-added user turn from the store before yielding so the
+            // generator-cleanup path doesn't strand the removal — and so the error
+            // event can carry the dropped text for UI restoration.
+            let droppedUserMessage;
             if (addedUserMessage && !stream && this.#isCurrentGeneration(gen)) {
                 this.conversationStore.removeLastUserMessage();
+                droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
+            }
+            if (stream && this.#isCurrentGeneration(gen)) {
+                this.toolLedger.markOpenCallsAborted(error instanceof Error ? error.message : String(error));
+                // Persist completed tool call/result pairs (and the recovery notice) into
+                // canonical history so the next user turn doesn't ship a request with two
+                // consecutive user messages and no record of the tool activity.
+                const reconciled = reconcileHistoryWithToolLedger(this.conversationStore.getHistory(), this.toolLedger.export());
+                if (reconciled.addedCompletedPairs > 0 || reconciled.droppedIncompleteCalls > 0) {
+                    this.conversationStore.replaceHistory(reconciled.history);
+                }
+                const recoverySummary = this.toolLedger.getRecoverySummary();
+                if (recoverySummary) {
+                    yield {
+                        type: 'tool_recovery',
+                        recoveredCallIds: recoverySummary.recoveredCallIds,
+                        droppedCallIds: recoverySummary.droppedCallIds,
+                        message: recoverySummary.message,
+                    };
+                }
             }
+            yield {
+                type: 'error',
+                message: describeError(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+                ...(droppedUserMessage ? { droppedUserMessage } : {}),
+            };
             this.logger.error('Conversation stream error', {
                 eventType: 'stream.failed',
                 category: 'stream',
                 phase: 'abort',
                 sessionId: this.id,
                 traceId: this.logger.getCorrelationId(),
-                errorMessage: error instanceof Error ? error.message : String(error),
+                errorMessage: describeError(error),
+                stack: error instanceof Error ? error.stack : undefined,
             });
             throw error;
         }
@@ -438,9 +909,19 @@ export class ConversationSession {
         if (!plan) {
             return;
         }
+        if (answer !== 'y') {
+            const interruption = plan.pendingApprovalContext.interruption;
+            const callId = getCallIdFromObject(interruption);
+            const output = rejectionReason
+                ? `Tool execution was not approved. User's reason: ${rejectionReason}`
+                : 'Tool execution was not approved.';
+            this.toolLedger.recordAbortedApproval(output, output, callId);
+        }
         const { pendingApprovalContext: { state, toolCallArgumentsById, emittedCommandIds: previouslyEmittedIds }, toolStartedEvent, removeInterceptor, } = plan;
         if (toolStartedEvent) {
-            yield toolStartedEvent;
+            const filtered = this.#dedupeToolStarted(toolStartedEvent);
+            if (filtered)
+                yield filtered;
         }
         // Restore cached tool-call arguments so continuation outputs can attach them
         this.toolCallArgumentsById.clear();
@@ -455,22 +936,66 @@ export class ConversationSession {
                 try {
                     const stream = (await this.agentClient.continueRunStream(state, {
                         previousResponseId: this.previousResponseId,
+                        sessionId: this.id,
                     }));
                     const acc = createStreamAccumulator();
-                    yield* processStreamEvents(stream, acc, {
+                    for await (const event of processStreamEvents(stream, acc, {
                         toolCallArgumentsById: this.toolCallArgumentsById,
                         emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                         preserveExistingToolArgs: true,
-                    }, { logger: this.logger, sessionId: this.id });
+                        onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOf(item);
+                            if (cid && this.logSink) {
+                                const entry = this.toolLedger.export().find((e) => e.callId === cid);
+                                this.#log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOf(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOf(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.logger, sessionId: this.id })) {
+                        const filtered = this.#dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
                     if (this.#isCurrentGeneration(gen)) {
                         this.previousResponseId = stream.lastResponseId ?? null;
-                        this.conversationStore.updateFromResult(stream);
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'continueRunStream',
+                            stream,
+                        });
+                        const s = stream;
+                        const terminal = !stream.interruptions || stream.interruptions.length === 0;
+                        if (terminal) {
+                            if (this.#inputSurgeKind === 'delta') {
+                                this.conversationStore.appendOutput(s.output);
+                            }
+                            else {
+                                this.conversationStore.replaceHistory(s.history);
+                            }
+                        }
                     }
                     // Merge previously emitted command IDs with newly emitted ones
                     // This prevents duplicates when result.history contains commands from the initial stream
                     const allEmittedIds = new Set([...previouslyEmittedIds, ...acc.emittedCommandIds]);
                     const resolvedResult = yield* this.#buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, allEmittedIds, acc.latestUsage);
                     if (resolvedResult.type === 'approval_required') {
+                        if (resolvedResult.approval.callId) {
+                            this.toolLedger.recordFunctionCall({
+                                type: 'function_call',
+                                callId: resolvedResult.approval.callId,
+                                name: resolvedResult.approval.toolName,
+                                arguments: resolvedResult.approval.argumentsText,
+                            });
+                        }
                         this.logger.debug('Tool approval required', {
                             eventType: 'approval.required',
                             category: 'approval',
@@ -517,9 +1042,19 @@ export class ConversationSession {
             }
         }
         catch (error) {
+            this.logger.error('Conversation stream error during continuation', {
+                eventType: 'stream.failed',
+                category: 'stream',
+                phase: 'abort',
+                sessionId: this.id,
+                traceId: this.logger.getCorrelationId(),
+                errorMessage: describeError(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             yield {
                 type: 'error',
-                message: error instanceof Error ? error.message : String(error),
+                message: describeError(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
             };
             throw error;
         }
@@ -531,14 +1066,18 @@ export class ConversationSession {
     async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, } = {}) {
         const turn = normalizeUserTurn(input);
         return this.#withTrafficContext(turn.text, async () => {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
+            const wrappedOnEvent = (event) => {
+                this.#dispatchEventToLog(event);
+                onEvent?.(event);
+            };
+            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, wrappedOnEvent);
             let result;
             try {
                 result = await collectTerminalResult(this.run(input, { hallucinationRetryCount }), {
                     onTextChunk,
                     onReasoningChunk,
                     onCommandMessage,
-                    onEvent,
+                    onEvent: wrappedOnEvent,
                     getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
                     onFinalEvent: (event) => {
                         this.logger.debug('sendMessage received final event', {
@@ -566,15 +1105,24 @@ export class ConversationSession {
         if (!this.approvalFlow.getPending()) {
             return null;
         }
+        this.#log({
+            type: 'approval_resolved',
+            answer: answer === 'y' ? 'y' : 'n',
+            ...(rejectionReason ? { rejectionReason } : {}),
+        });
         return this.#withTrafficContext(undefined, async () => {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
+            const wrappedOnEvent = (event) => {
+                this.#dispatchEventToLog(event);
+                onEvent?.(event);
+            };
+            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, wrappedOnEvent);
             let result;
             try {
                 result = await collectTerminalResult(this['continue']({ answer, rejectionReason }), {
                     onTextChunk,
                     onReasoningChunk,
                     onCommandMessage,
-                    onEvent,
+                    onEvent: wrappedOnEvent,
                     getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
                     onFinalEvent: (event) => {
                         this.logger.debug('handleApprovalDecision received final event', {
@@ -606,6 +1154,7 @@ export class ConversationSession {
             emittedCommandIds,
             usage,
             toolCallArgumentsById: this.toolCallArgumentsById,
+            turnItems: this.currentPersistedTurnItems,
         }, {
             approvalFlow: this.approvalFlow,
             shellAutoApproval: this.shellAutoApproval,
@@ -621,6 +1170,7 @@ export class ConversationSession {
         let continuationApprovalUsage;
         const commandMessages = [];
         let approvalRequiredResult;
+        let continuationTurnItems;
         for await (const event of this['continue']({ answer: 'y' })) {
             if (event.type === 'approval_required') {
                 continuationApprovalUsage = event.usage;
@@ -649,7 +1199,9 @@ export class ConversationSession {
                 if (event.commandMessages) {
                     commandMessages.push(...event.commandMessages);
                 }
-                yield event;
+                if (event.turnItems) {
+                    continuationTurnItems = event.turnItems;
+                }
             }
             else {
                 yield event;
@@ -669,6 +1221,7 @@ export class ConversationSession {
             finalText: finalText || 'Done.',
             ...(reasoningText ? { reasoningText } : {}),
             ...(combinedUsage && Object.keys(combinedUsage).length > 0 ? { usage: combinedUsage } : {}),
+            turnItems: continuationTurnItems ?? this.currentPersistedTurnItems,
         };
     }
 }