@qduc/term2 0.7.0 → 0.7.1

package/dist/services/conversation-session.js

@@ -3,7 +3,7 @@ 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';
@@ -11,29 +11,8 @@ import { buildConversationResult, toTerminalEvent } from './conversation-result-
 import { normalizeUserTurn } from '../types/user-turn.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 { reconcileHistoryWithToolLedger, ToolExecutionLedger, callIdOf, toolNameOf, outputOf, } 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;
@@ -85,8 +64,11 @@ export class ConversationSession {
     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;
@@ -154,28 +136,11 @@ export class ConversationSession {
     #buildOutgoingInput(turn, { includeTurn }) {
         const provider = this.#getProviderForGuard() ?? 'openai';
         const supportsChaining = supportsConversationChaining(provider);
-        const history = this.conversationStore.getHistory();
+        const history = this.#getCanonicalHistory();
         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',
@@ -224,6 +189,8 @@ export class ConversationSession {
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
         this.largeUncachedInputGuard.reset();
+        this.#inputSurgeKind = 'delta';
+        this.#resetPersistedTurnState();
         const clearConversations = getMethod(this.agentClient, 'clearConversations');
         clearConversations?.call(this.agentClient);
     }
@@ -240,6 +207,8 @@ export class ConversationSession {
         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;
     }
@@ -259,6 +228,8 @@ export class ConversationSession {
         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;
     }
@@ -305,13 +276,69 @@ export class ConversationSession {
             : this.settingsService?.get('agent.provider');
         const model = this.settingsService?.get('agent.model');
         return {
-            history: this.conversationStore.getHistory(),
+            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;
@@ -330,7 +357,20 @@ export class ConversationSession {
         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,
@@ -340,6 +380,11 @@ export class ConversationSession {
                 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({
@@ -364,24 +409,44 @@ export class ConversationSession {
                 this.#log({ type: 'subagent_completed', result: event.result });
                 return;
             case 'error':
-                this.#log({ type: 'error', message: event.message, ...(event.kind ? { kind: event.kind } : {}) });
+                this.#log({
+                    type: 'error',
+                    message: event.message,
+                    ...(event.kind ? { kind: event.kind } : {}),
+                    ...(event.stack ? { stack: event.stack } : {}),
+                });
                 return;
             case 'final': {
-                const snapshot = this.getCurrentSnapshot();
-                this.#log({
-                    type: 'assistant_final',
-                    message: {
-                        id: `bot-${snapshot.history.length}-${Date.now()}`,
-                        sender: 'bot',
-                        status: 'finalized',
+                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,
-                        ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
-                    },
-                    finalText: event.finalText,
-                    ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
+                    });
+                }
+                // 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 } : {}),
-                    snapshot,
+                    state: turnState,
                 });
+                this.#resetPersistedTurnState();
                 return;
             }
             default:
@@ -398,9 +463,13 @@ export class ConversationSession {
         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(),
         };
@@ -433,21 +502,28 @@ export class ConversationSession {
     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);
@@ -504,15 +580,15 @@ export class ConversationSession {
                         onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
                         onFunctionResultItem: (item) => {
                             this.toolLedger.recordFunctionResult(item);
-                            const cid = callIdOfLocal(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 ?? toolNameOfLocal(item),
+                                    toolName: entry?.toolName ?? toolNameOf(item),
                                     status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
-                                    output: entry?.output ?? outputOfLocal(item),
+                                    output: entry?.output ?? outputOf(item),
                                     ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
                                 });
                             }
@@ -530,7 +606,16 @@ export class ConversationSession {
                             source: 'abortResolution',
                             stream: continuedStream,
                         });
-                        this.conversationStore.updateFromResult(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) {
@@ -563,22 +648,10 @@ export class ConversationSession {
             // 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 { streamInput, inputSurgeKind, modeNoticeToPersist } = this.#buildOutgoingInput(turn, {
+            const { streamInput, inputSurgeKind } = this.#buildOutgoingInput(turn, {
                 includeTurn: false,
             });
-            if (this.pendingModeNotice) {
-                this.pendingModeNotice = null;
-            }
-            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);
-            }
+            this.#inputSurgeKind = inputSurgeKind;
             const surgeDecision = this.inputSurgeGuard.inspect(streamInput, { kind: inputSurgeKind });
             if (surgeDecision.action === 'block') {
                 let droppedUserMessage;
@@ -628,7 +701,16 @@ export class ConversationSession {
                     source: 'startStream',
                     stream,
                 });
-                this.conversationStore.updateFromResult(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 (inputSurgeKind === 'delta') {
@@ -649,6 +731,14 @@ export class ConversationSession {
                 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',
@@ -694,6 +784,45 @@ export class ConversationSession {
                 });
                 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', {
@@ -734,6 +863,13 @@ export class ConversationSession {
             }
             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 {
@@ -747,6 +883,7 @@ export class ConversationSession {
             yield {
                 type: 'error',
                 message: describeError(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
                 ...(droppedUserMessage ? { droppedUserMessage } : {}),
             };
             this.logger.error('Conversation stream error', {
@@ -756,6 +893,7 @@ export class ConversationSession {
                 sessionId: this.id,
                 traceId: this.logger.getCorrelationId(),
                 errorMessage: describeError(error),
+                stack: error instanceof Error ? error.stack : undefined,
             });
             throw error;
         }
@@ -771,6 +909,14 @@ 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) {
             const filtered = this.#dedupeToolStarted(toolStartedEvent);
@@ -800,15 +946,15 @@ export class ConversationSession {
                         onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
                         onFunctionResultItem: (item) => {
                             this.toolLedger.recordFunctionResult(item);
-                            const cid = callIdOfLocal(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 ?? toolNameOfLocal(item),
+                                    toolName: entry?.toolName ?? toolNameOf(item),
                                     status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
-                                    output: entry?.output ?? outputOfLocal(item),
+                                    output: entry?.output ?? outputOf(item),
                                     ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
                                 });
                             }
@@ -826,13 +972,30 @@ export class ConversationSession {
                             source: 'continueRunStream',
                             stream,
                         });
-                        this.conversationStore.updateFromResult(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',
@@ -879,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: describeError(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
             };
             throw error;
         }
@@ -981,6 +1154,7 @@ export class ConversationSession {
             emittedCommandIds,
             usage,
             toolCallArgumentsById: this.toolCallArgumentsById,
+            turnItems: this.currentPersistedTurnItems,
         }, {
             approvalFlow: this.approvalFlow,
             shellAutoApproval: this.shellAutoApproval,
@@ -996,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;
@@ -1024,7 +1199,9 @@ export class ConversationSession {
                 if (event.commandMessages) {
                     commandMessages.push(...event.commandMessages);
                 }
-                yield event;
+                if (event.turnItems) {
+                    continuationTurnItems = event.turnItems;
+                }
             }
             else {
                 yield event;
@@ -1044,6 +1221,7 @@ export class ConversationSession {
             finalText: finalText || 'Done.',
             ...(reasoningText ? { reasoningText } : {}),
             ...(combinedUsage && Object.keys(combinedUsage).length > 0 ? { usage: combinedUsage } : {}),
+            turnItems: continuationTurnItems ?? this.currentPersistedTurnItems,
         };
     }
 }