@qduc/term2 0.6.0 → 0.7.0

package/dist/services/conversation-session.js

@@ -1,5 +1,5 @@
 import { ConversationStore } from './conversation-store.js';
-import { decideRetry, MAX_HALLUCINATION_RETRIES } from './conversation-retry-policy.js';
+import { decideRetry, isTransientRetryableError, MAX_HALLUCINATION_RETRIES, MAX_TRANSIENT_RETRIES, } from './conversation-retry-policy.js';
 import { getProvider } from '../providers/index.js';
 import { ApprovalState } from './approval-state.js';
 import { collectTerminalResult } from './terminal-result-collector.js';
@@ -9,13 +9,68 @@ 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, } from './tool-execution-ledger.js';
+import { describeError } from '../utils/error-helpers.js';
+const asRecordLocal = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+const rawItemLocal = (item) => {
+    const rec = asRecordLocal(item);
+    if (!rec)
+        return null;
+    return asRecordLocal(rec.rawItem) ?? rec;
+};
+const callIdOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    const cid = raw?.callId ?? raw?.call_id ?? raw?.tool_call_id ?? raw?.toolCallId ?? raw?.id;
+    return typeof cid === 'string' && cid ? cid : null;
+};
+const toolNameOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    const name = raw?.name ?? asRecordLocal(item)?.name;
+    return typeof name === 'string' && name ? name : 'unknown';
+};
+const outputOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    return raw?.output ?? asRecordLocal(item)?.output;
+};
 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;
     agentClient;
     logger;
     conversationStore;
@@ -23,14 +78,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;
     settingsService;
     pendingModeNotice = null;
-    constructor(id, { agentClient, deps, }) {
+    logSink = null;
+    constructor(id, { agentClient, deps, sessionStartedAt, }) {
         this.id = id;
+        this.startedAt = sessionStartedAt ?? new Date().toISOString();
         this.agentClient = agentClient;
         this.logger = deps.logger;
         this.settingsService = deps.settingsService;
@@ -48,6 +108,107 @@ export class ConversationSession {
             sessionId: this.id,
         });
     }
+    #getTrafficMode() {
+        if (!this.settingsService)
+            return 'standard';
+        if (this.settingsService.get('app.orchestratorMode'))
+            return 'orchestrator';
+        if (this.settingsService.get('app.liteMode'))
+            return 'lite';
+        if (this.settingsService.get('app.planMode'))
+            return 'plan';
+        if (this.settingsService.get('app.mentorMode'))
+            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.conversationStore.getHistory();
+        const outgoingHistory = includeTurn ? [...history, this.#makeUserInputItem(turn)] : history;
+        const useChaining = supportsChaining && (!!this.previousResponseId || outgoingHistory.length <= 1);
+        const notice = this.pendingModeNotice;
+        const latestInput = outgoingHistory[outgoingHistory.length - 1] ?? turn.text;
+        const chainedInput = turn.images?.length ? latestInput : turn.text;
+        if (notice) {
+            if (useChaining) {
+                const userItem = typeof chainedInput === 'string' ? { role: 'user', type: 'message', content: chainedInput } : chainedInput;
+                const noticeItem = { role: 'system', type: 'message', content: notice };
+                return {
+                    streamInput: [noticeItem, userItem],
+                    inputSurgeKind: 'delta',
+                };
+            }
+            const noticeItem = { role: 'user', type: 'message', content: notice };
+            return {
+                streamInput: [...outgoingHistory, noticeItem],
+                inputSurgeKind: 'full_history',
+                modeNoticeToPersist: notice,
+            };
+        }
+        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 ?? '';
+    }
+    #withTrafficContext(currentTurn, fn) {
+        const runner = this.logger.runWithTrafficContext;
+        if (!runner)
+            return fn();
+        return runner.call(this.logger, {
+            sessionId: this.id,
+            sessionStartedAt: this.startedAt,
+            firstUserMessagePreview: this.#getFirstUserMessagePreview(currentTurn),
+            mode: this.#getTrafficMode(),
+            traceId: this.logger.getCorrelationId(),
+        }, fn);
+    }
     #isCurrentGeneration(gen) {
         return gen === this.generation;
     }
@@ -58,8 +219,11 @@ 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();
         const clearConversations = getMethod(this.agentClient, 'clearConversations');
         clearConversations?.call(this.agentClient);
     }
@@ -72,8 +236,11 @@ 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.#log({ type: 'undo', removedUserTurns: 1, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     listUserTurns() {
@@ -88,8 +255,11 @@ 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.#log({ type: 'undo', removedUserTurns: n, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     setModel(model) {
@@ -104,27 +274,160 @@ 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.conversationStore.getHistory(),
+            previousResponseId: this.previousResponseId,
+            toolLedger: this.toolLedger.export(),
+            ...(model ? { model } : {}),
+            ...(provider ? { provider } : {}),
+        };
+    }
+    #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 'tool_started':
+                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 });
+                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 } : {}) });
+                return;
+            case 'final': {
+                const snapshot = this.getCurrentSnapshot();
+                this.#log({
+                    type: 'assistant_final',
+                    message: {
+                        id: `bot-${snapshot.history.length}-${Date.now()}`,
+                        sender: 'bot',
+                        status: 'finalized',
+                        text: event.finalText,
+                        ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
+                    },
+                    finalText: event.finalText,
+                    ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
+                    ...(event.usage ? { usage: event.usage } : {}),
+                    snapshot,
+                });
+                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;
+    }
     exportState() {
         return {
             history: this.conversationStore.getHistory(),
             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) {
@@ -150,6 +453,8 @@ export class ConversationSession {
         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',
@@ -165,6 +470,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) {
@@ -182,16 +493,43 @@ 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 = callIdOfLocal(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 ?? toolNameOfLocal(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOfLocal(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;
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'abortResolution',
+                            stream: continuedStream,
+                        });
                         this.conversationStore.updateFromResult(continuedStream);
                     }
                     // Check if another interruption occurred
@@ -220,49 +558,33 @@ 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;
+            const { streamInput, inputSurgeKind, modeNoticeToPersist } = this.#buildOutgoingInput(turn, {
+                includeTurn: false,
+            });
             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;
+            if (modeNoticeToPersist) {
+                // 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(modeNoticeToPersist);
             }
-            const inputSurgeKind = useChaining ? 'delta' : 'full_history';
             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',
@@ -278,24 +600,38 @@ 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;
+                warnIfStreamHistoryReplayedTools({
+                    logger: this.logger,
+                    sessionId: this.id,
+                    source: 'startStream',
+                    stream,
+                });
                 this.conversationStore.updateFromResult(stream);
             }
             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 {
@@ -304,6 +640,14 @@ 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') {
                 this.logger.debug('Tool approval required', {
                     eventType: 'approval.required',
@@ -343,6 +687,7 @@ 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,
@@ -368,6 +713,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);
                     }
@@ -378,20 +724,38 @@ 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));
+                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),
+                ...(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),
             });
             throw error;
         }
@@ -409,7 +773,9 @@ export class ConversationSession {
         }
         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();
@@ -419,41 +785,103 @@ export class ConversationSession {
             }
         }
         try {
-            const stream = (await this.agentClient.continueRunStream(state, {
-                previousResponseId: this.previousResponseId,
-            }));
-            const acc = createStreamAccumulator();
-            yield* processStreamEvents(stream, acc, {
-                toolCallArgumentsById: this.toolCallArgumentsById,
-                emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
-                preserveExistingToolArgs: true,
-            }, { logger: this.logger, sessionId: this.id });
-            if (this.#isCurrentGeneration(gen)) {
-                this.previousResponseId = stream.lastResponseId ?? null;
-                this.conversationStore.updateFromResult(stream);
-            }
-            // 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') {
-                this.logger.debug('Tool approval required', {
-                    eventType: 'approval.required',
-                    category: 'approval',
-                    phase: 'approval',
-                    sessionId: this.id,
-                    traceId: this.logger.getCorrelationId(),
-                    toolName: resolvedResult.approval.toolName,
-                });
-                yield toTerminalEvent(resolvedResult);
-                return;
+            let transientRetryCount = 0;
+            while (true) {
+                try {
+                    const stream = (await this.agentClient.continueRunStream(state, {
+                        previousResponseId: this.previousResponseId,
+                        sessionId: this.id,
+                    }));
+                    const acc = createStreamAccumulator();
+                    for await (const event of processStreamEvents(stream, acc, {
+                        toolCallArgumentsById: this.toolCallArgumentsById,
+                        emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
+                        preserveExistingToolArgs: true,
+                        onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOfLocal(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 ?? toolNameOfLocal(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOfLocal(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;
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'continueRunStream',
+                            stream,
+                        });
+                        this.conversationStore.updateFromResult(stream);
+                    }
+                    // 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') {
+                        this.logger.debug('Tool approval required', {
+                            eventType: 'approval.required',
+                            category: 'approval',
+                            phase: 'approval',
+                            sessionId: this.id,
+                            traceId: this.logger.getCorrelationId(),
+                            toolName: resolvedResult.approval.toolName,
+                        });
+                        yield toTerminalEvent(resolvedResult);
+                        return;
+                    }
+                    yield toTerminalEvent(resolvedResult);
+                    return;
+                }
+                catch (error) {
+                    if (isTransientRetryableError(error) && transientRetryCount < MAX_TRANSIENT_RETRIES) {
+                        transientRetryCount++;
+                        const delay = Math.min(500 * Math.pow(2, transientRetryCount - 1), 30000);
+                        this.logger.warn('Transient error in continuation, retrying', {
+                            eventType: 'retry.transient',
+                            category: 'retry',
+                            phase: 'retry',
+                            retryType: 'upstream',
+                            retryAttempt: transientRetryCount,
+                            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: 'continuation',
+                            attempt: transientRetryCount,
+                            maxRetries: MAX_TRANSIENT_RETRIES,
+                            errorMessage: error instanceof Error ? error.message : String(error),
+                            retryType: 'upstream',
+                        };
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    throw error;
+                }
             }
-            yield toTerminalEvent(resolvedResult);
         }
         catch (error) {
             yield {
                 type: 'error',
-                message: error instanceof Error ? error.message : String(error),
+                message: describeError(error),
             };
             throw error;
         }
@@ -463,69 +891,87 @@ export class ConversationSession {
         }
     }
     async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, } = {}) {
-        getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
-        let result;
-        try {
-            result = await collectTerminalResult(this.run(input, { hallucinationRetryCount }), {
-                onTextChunk,
-                onReasoningChunk,
-                onCommandMessage,
-                onEvent,
-                getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
-                onFinalEvent: (event) => {
-                    this.logger.debug('sendMessage received final event', {
-                        sessionId: this.id,
-                        hasUsage: Boolean(event.usage),
-                        usage: event.usage,
-                    });
-                },
-            });
-        }
-        finally {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, null);
-        }
-        if (result.type === 'response') {
-            this.logger.debug('sendMessage returning response', {
-                sessionId: this.id,
-                hasUsage: Boolean(result.usage),
-                usage: result.usage,
-            });
-        }
-        return result;
+        const turn = normalizeUserTurn(input);
+        return this.#withTrafficContext(turn.text, async () => {
+            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: wrappedOnEvent,
+                    getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
+                    onFinalEvent: (event) => {
+                        this.logger.debug('sendMessage received final event', {
+                            sessionId: this.id,
+                            hasUsage: Boolean(event.usage),
+                            usage: event.usage,
+                        });
+                    },
+                });
+            }
+            finally {
+                getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, null);
+            }
+            if (result.type === 'response') {
+                this.logger.debug('sendMessage returning response', {
+                    sessionId: this.id,
+                    hasUsage: Boolean(result.usage),
+                    usage: result.usage,
+                });
+            }
+            return result;
+        });
     }
     async handleApprovalDecision(answer, rejectionReason, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, } = {}) {
         if (!this.approvalFlow.getPending()) {
             return null;
         }
-        getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
-        let result;
-        try {
-            result = await collectTerminalResult(this['continue']({ answer, rejectionReason }), {
-                onTextChunk,
-                onReasoningChunk,
-                onCommandMessage,
-                onEvent,
-                getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
-                onFinalEvent: (event) => {
-                    this.logger.debug('handleApprovalDecision received final event', {
-                        sessionId: this.id,
-                        hasUsage: Boolean(event.usage),
-                        usage: event.usage,
-                    });
-                },
-            });
-        }
-        finally {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, null);
-        }
-        if (result.type === 'response') {
-            this.logger.debug('handleApprovalDecision returning response', {
-                sessionId: this.id,
-                hasUsage: Boolean(result.usage),
-                usage: result.usage,
-            });
-        }
-        return result;
+        this.#log({
+            type: 'approval_resolved',
+            answer: answer === 'y' ? 'y' : 'n',
+            ...(rejectionReason ? { rejectionReason } : {}),
+        });
+        return this.#withTrafficContext(undefined, async () => {
+            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: wrappedOnEvent,
+                    getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
+                    onFinalEvent: (event) => {
+                        this.logger.debug('handleApprovalDecision received final event', {
+                            sessionId: this.id,
+                            hasUsage: Boolean(event.usage),
+                            usage: event.usage,
+                        });
+                    },
+                });
+            }
+            finally {
+                getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, null);
+            }
+            if (result.type === 'response') {
+                this.logger.debug('handleApprovalDecision returning response', {
+                    sessionId: this.id,
+                    hasUsage: Boolean(result.usage),
+                    usage: result.usage,
+                });
+            }
+            return result;
+        });
     }
     async *#buildAndResolve(result, finalOutputOverride, reasoningOutputOverride, emittedCommandIds, usage) {
         const outcome = await buildConversationResult({