@qduc/term2 0.1.8 → 0.3.0

package/dist/services/conversation-session.js

@@ -1,104 +1,14 @@
-import { extractCommandMessages, markToolCallAsApprovalRejection } from '../utils/extract-command-messages.js';
 import { ConversationStore } from './conversation-store.js';
-import { ModelBehaviorError } from '@openai/agents';
-import { extractUsage } from '../utils/token-usage.js';
+import { decideRetry, MAX_HALLUCINATION_RETRIES } from './conversation-retry-policy.js';
 import { getProvider } from '../providers/index.js';
-import { extractReasoningDelta, extractTextDelta } from './stream-event-parsing.js';
-import { captureToolCallArguments, emitCommandMessagesFromItems } from './command-message-streaming.js';
 import { ApprovalState } from './approval-state.js';
-import { createInvalidToolCallDiagnostic } from './logging-contract.js';
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
-const getString = (record, key) => {
-    const value = record?.[key];
-    return typeof value === 'string' ? value : undefined;
-};
-const getMethod = (target, key) => {
-    const record = asRecord(target);
-    const candidate = record?.[key];
-    return typeof candidate === 'function' ? candidate : null;
-};
-const getCallIdFromObject = (value) => {
-    const record = asRecord(value);
-    const callId = getString(record, 'callId') ??
-        getString(record, 'call_id') ??
-        getString(record, 'tool_call_id') ??
-        getString(record, 'toolCallId') ??
-        getString(record, 'id');
-    if (callId) {
-        return callId;
-    }
-    const rawItem = asRecord(record?.rawItem);
-    return (getString(rawItem, 'callId') ??
-        getString(rawItem, 'call_id') ??
-        getString(rawItem, 'tool_call_id') ??
-        getString(rawItem, 'toolCallId') ??
-        getString(rawItem, 'id'));
-};
-const getCommandFromArgs = (args) => {
-    if (!args) {
-        return '';
-    }
-    if (typeof args === 'string') {
-        try {
-            const parsed = JSON.parse(args);
-            // Handle shell tool's command parameter
-            if (parsed?.command) {
-                return parsed.command;
-            }
-            // Fallback for old 'commands' array format
-            if (Array.isArray(parsed?.commands)) {
-                return parsed.commands.join('\n');
-            }
-            return JSON.stringify(parsed);
-        }
-        catch {
-            return args;
-        }
-    }
-    if (typeof args === 'object') {
-        const argsRecord = asRecord(args);
-        // Handle shell tool's command parameter
-        const cmdFromObject = argsRecord?.command !== undefined ? String(argsRecord.command) : undefined;
-        // Fallback for old 'commands' array format
-        if (Array.isArray(argsRecord?.commands)) {
-            return argsRecord.commands.join('\n');
-        }
-        let argsFromObject;
-        if (argsRecord?.arguments !== undefined) {
-            const rawArguments = argsRecord.arguments;
-            if (typeof rawArguments === 'string') {
-                try {
-                    argsFromObject = JSON.stringify(JSON.parse(rawArguments));
-                }
-                catch {
-                    argsFromObject = String(rawArguments);
-                }
-            }
-            else if (rawArguments !== undefined) {
-                argsFromObject = String(rawArguments);
-            }
-        }
-        return cmdFromObject ?? argsFromObject ?? JSON.stringify(args);
-    }
-    return String(args);
-};
-/**
- * Maximum number of retries when the model hallucinates a tool
- */
-const MAX_HALLUCINATION_RETRIES = 2;
-/**
- * Check if an error is a recoverable model behavior error (hallucination, parsing error, etc.)
- */
-const isRecoverableModelError = (error) => {
-    if (!(error instanceof ModelBehaviorError)) {
-        return false;
-    }
-    const message = error.message.toLowerCase();
-    return ((message.includes('tool') && message.includes('not found')) || // Hallucination
-        message.includes('model did not produce a final response') || // Give up/exhausted
-        message.includes('parsing tool arguments') || // Bad JSON
-        message.includes('valid json'));
-};
+import { collectTerminalResult } from './terminal-result-collector.js';
+import { getMethod } 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';
 const supportsConversationChaining = (providerId) => {
     const providerDef = getProvider(providerId);
     return providerDef?.capabilities?.supportsConversationChaining ?? false;
@@ -110,15 +20,29 @@ export class ConversationSession {
     conversationStore;
     previousResponseId = null;
     approvalState = new ApprovalState();
-    textDeltaCount = 0;
-    reasoningDeltaCount = 0;
     toolCallArgumentsById = new Map();
     emittedInvalidToolCallPackets = new Set();
-    constructor(id, { agentClient, deps }) {
+    shellAutoApproval;
+    approvalFlow;
+    settingsService;
+    constructor(id, { agentClient, deps, }) {
         this.id = id;
         this.agentClient = agentClient;
         this.logger = deps.logger;
+        this.settingsService = deps.settingsService;
         this.conversationStore = new ConversationStore();
+        this.shellAutoApproval = new ShellAutoApprovalResolver({
+            conversationStore: this.conversationStore,
+            agentClient: this.agentClient,
+            logger: this.logger,
+            settingsService: this.settingsService,
+        });
+        this.approvalFlow = new ApprovalFlowCoordinator({
+            agentClient: this.agentClient,
+            approvalState: this.approvalState,
+            logger: this.logger,
+            sessionId: this.id,
+        });
     }
     reset() {
         this.previousResponseId = null;
@@ -126,6 +50,7 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.shellAutoApproval.clearCache();
         const clearConversations = getMethod(this.agentClient, 'clearConversations');
         clearConversations?.call(this.agentClient);
     }
@@ -156,38 +81,30 @@ export class ConversationSession {
      * Abort the current running operation
      */
     abort() {
-        this.agentClient.abort();
-        // Save pending approval context so we can handle it in the next message
-        if (this.approvalState.abortPending()) {
-            this.logger.debug('Aborted approval - will handle rejection on next message', {
-                eventType: 'approval.aborted',
-                category: 'approval',
-                phase: 'abort',
-                sessionId: this.id,
-                traceId: this.logger.getCorrelationId(),
-            });
-        }
+        this.approvalFlow.abort();
     }
     /**
      * 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(text, { hallucinationRetryCount = 0, skipUserMessage = false, } = {}) {
+    async *run(input, { hallucinationRetryCount = 0, skipUserMessage = false, } = {}) {
         let stream = null;
+        const turn = normalizeUserTurn(input);
+        const text = turn.text;
         try {
-            this.logger.info('Conversation stream start', {
+            this.logger.debug('Conversation stream start', {
                 eventType: 'stream.started',
                 category: 'stream',
                 phase: 'request_start',
                 sessionId: this.id,
                 traceId: this.logger.getCorrelationId(),
             });
-            const abortedContext = this.approvalState.consumeAborted();
+            const abortedContext = this.approvalFlow.consumeAborted();
             const shouldAddUserMessage = !skipUserMessage && !abortedContext;
             // Maintain canonical local history regardless of provider.
             if (shouldAddUserMessage) {
-                this.conversationStore.addUserMessage(text);
+                this.conversationStore.addUserTurn(turn);
             }
             // 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.
@@ -195,56 +112,39 @@ export class ConversationSession {
                 this.logger.debug('Resolving aborted approval with fake execution', {
                     message: text,
                 });
-                const { state, interruption, emittedCommandIds, toolCallArgumentsById } = abortedContext;
-                const interruptionRecord = asRecord(interruption);
                 // Restore cached tool-call arguments captured before abort so continuation can attach them
                 this.toolCallArgumentsById.clear();
-                if (toolCallArgumentsById?.size) {
-                    for (const [key, value] of toolCallArgumentsById.entries()) {
+                if (abortedContext.toolCallArgumentsById?.size) {
+                    for (const [key, value] of abortedContext.toolCallArgumentsById.entries()) {
                         this.toolCallArgumentsById.set(key, value);
                     }
                 }
-                // Add interceptor for this tool execution
-                const toolName = getString(interruptionRecord, 'name') ?? 'unknown';
-                const expectedCallId = getCallIdFromObject(interruption);
-                const rejectionMessage = `Tool execution was not approved. User provided new input instead: ${text}`;
-                const removeInterceptor = this.agentClient.addToolInterceptor(async (name, _params, toolCallId) => {
-                    // Match both tool name and call ID for stricter matching
-                    if (name === toolName && (!expectedCallId || toolCallId === expectedCallId)) {
-                        markToolCallAsApprovalRejection(toolCallId ?? expectedCallId);
-                        return rejectionMessage;
-                    }
-                    return null;
-                });
-                const approve = getMethod(state, 'approve');
-                approve?.call(state, interruption);
+                const { removeInterceptor } = this.approvalFlow.prepareAbortResolution(abortedContext, text);
                 try {
-                    const continuedStream = (await this.agentClient.continueRunStream(state, {
+                    const continuedStream = (await this.agentClient.continueRunStream(abortedContext.state, {
                         previousResponseId: this.previousResponseId,
                     }));
-                    const acc = {
-                        finalOutput: '',
-                        reasoningOutput: '',
-                        emittedCommandIds: new Set(emittedCommandIds),
-                        latestUsage: undefined,
-                    };
-                    yield* this.#streamEvents(continuedStream, acc, {
+                    const acc = createStreamAccumulator();
+                    acc.emittedCommandIds = new Set(abortedContext.emittedCommandIds);
+                    yield* processStreamEvents(continuedStream, acc, {
+                        toolCallArgumentsById: this.toolCallArgumentsById,
+                        emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                         preserveExistingToolArgs: true,
-                    });
+                    }, { logger: this.logger, sessionId: this.id });
                     this.previousResponseId = continuedStream.lastResponseId ?? null;
                     this.conversationStore.updateFromResult(continuedStream);
                     // Check if another interruption occurred
                     if (continuedStream.interruptions && continuedStream.interruptions.length > 0) {
                         this.logger.warn('Another interruption occurred after fake execution - handling as approval');
                         // Let the normal flow handle this
-                        const result = this.#buildResult(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
-                        yield this.#toTerminalEvent(result);
+                        const resolvedResult = yield* this.#buildAndResolve(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                        yield toTerminalEvent(resolvedResult);
                         return;
                     }
                     // Successfully resolved - agent should now have processed the fake rejection
                     this.logger.debug('Fake execution completed, agent received rejection message');
-                    const result = this.#buildResult(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
-                    yield this.#toTerminalEvent(result);
+                    const resolvedResult = yield* this.#buildAndResolve(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                    yield toTerminalEvent(resolvedResult);
                     return;
                 }
                 catch (error) {
@@ -262,86 +162,63 @@ export class ConversationSession {
             const getProvider = getMethod(this.agentClient, 'getProvider');
             const provider = getProvider ? getProvider.call(this.agentClient) : 'openai';
             const supportsChaining = supportsConversationChaining(provider);
-            stream = (await this.agentClient.startStream(supportsChaining ? text : this.conversationStore.getHistory(), {
+            const history = this.conversationStore.getHistory();
+            const latestInput = history[history.length - 1] ?? text;
+            const chainedInput = turn.images?.length ? latestInput : text;
+            stream = (await this.agentClient.startStream(supportsChaining ? chainedInput : history, {
                 previousResponseId: this.previousResponseId,
             }));
-            const acc = {
-                finalOutput: '',
-                reasoningOutput: '',
-                emittedCommandIds: new Set(),
-                latestUsage: undefined,
-            };
-            yield* this.#streamEvents(stream, acc, {
+            const acc = createStreamAccumulator();
+            yield* processStreamEvents(stream, acc, {
+                toolCallArgumentsById: this.toolCallArgumentsById,
+                emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                 preserveExistingToolArgs: false,
-            });
+            }, { logger: this.logger, sessionId: this.id });
             this.previousResponseId = stream.lastResponseId ?? null;
             this.conversationStore.updateFromResult(stream);
-            // Build terminal event (approval_required or final)
-            const result = this.#buildResult(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, acc.latestUsage);
-            if (result.type === 'approval_required') {
-                this.logger.info('Tool approval required', {
+            const resolvedResult = yield* this.#buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, 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: result.approval.toolName,
+                    toolName: resolvedResult.approval.toolName,
                 });
-                yield this.#toTerminalEvent(result);
+                yield toTerminalEvent(resolvedResult);
                 return;
             }
-            yield this.#toTerminalEvent(result);
+            yield toTerminalEvent(resolvedResult);
         }
         catch (error) {
-            // Handle recoverable model errors (hallucination, parsing error, etc.)
-            if (isRecoverableModelError(error) && hallucinationRetryCount < MAX_HALLUCINATION_RETRIES) {
-                const message = error instanceof Error ? error.message : String(error);
-                const isHallucination = message.toLowerCase().includes('not found');
-                const isParsingError = message.toLowerCase().includes('parsing tool arguments') || message.toLowerCase().includes('valid json');
-                const toolName = isHallucination ? message.match(/Tool (\S+) not found/)?.[1] || 'unknown' : 'unknown';
+            const streamHistoryLength = Array.isArray(stream?.history) ? stream.history.length : 0;
+            const decision = decideRetry(error, hallucinationRetryCount, Boolean(stream), streamHistoryLength);
+            if (decision.kind === 'retry') {
                 this.logger.warn('Recoverable model error detected, retrying', {
                     eventType: 'retry.model_error',
                     category: 'retry',
                     phase: 'retry',
-                    toolName,
-                    retryType: isHallucination ? 'hallucination' : isParsingError ? 'parsing_error' : 'behavior',
-                    retryAttempt: hallucinationRetryCount + 1,
-                    attempt: hallucinationRetryCount + 1,
+                    toolName: decision.logPayload.toolName,
+                    retryType: decision.logPayload.retryType,
+                    retryAttempt: decision.attempt,
+                    attempt: decision.attempt,
                     maxRetries: MAX_HALLUCINATION_RETRIES,
                     sessionId: this.id,
                     traceId: this.logger.getCorrelationId(),
-                    errorMessage: message,
+                    errorMessage: decision.message,
                 });
-                yield {
-                    type: 'retry',
-                    toolName: isHallucination ? toolName : 'model',
-                    attempt: hallucinationRetryCount + 1,
-                    maxRetries: MAX_HALLUCINATION_RETRIES,
-                    errorMessage: message,
-                };
-                if (stream) {
-                    // Update conversation store with partial results (including the parse error output if it was yielded)
+                yield decision.retryEvent;
+                if (decision.hadStream && stream) {
                     this.conversationStore.updateFromResult(stream);
-                    // If stream produced no usable history, inject error context so the
-                    // model has explicit feedback about the failure on retry.
-                    const streamHistory = Array.isArray(stream.history) ? stream.history : [];
-                    if (streamHistory.length === 0) {
-                        this.conversationStore.addErrorContext(`[System: Previous attempt failed with error: ${message}. Please retry with corrected output.]`);
+                    if (decision.shouldInjectErrorContext) {
+                        this.conversationStore.addErrorContext(decision.errorContextMessage);
                     }
-                    // Retry from current state without re-adding user message
-                    yield* this.run(text, {
-                        hallucinationRetryCount: hallucinationRetryCount + 1,
-                        skipUserMessage: true,
-                    });
                 }
                 else {
-                    // Failed to start stream at all - clean slate retry
                     this.conversationStore.removeLastUserMessage();
-                    yield* this.run(text, {
-                        hallucinationRetryCount: hallucinationRetryCount + 1,
-                        // skipUserMessage defaults to false, so user message is re-added
-                    });
                 }
+                yield* this.run(turn, decision.nextRunOptions);
                 return;
             }
             yield {
@@ -365,58 +242,14 @@ export class ConversationSession {
      * Named as a string-literal because `continue` is a keyword.
      */
     async *['continue']({ answer, rejectionReason, }) {
-        const pendingApprovalContext = this.approvalState.getPending();
-        if (!pendingApprovalContext) {
+        const plan = this.approvalFlow.prepareContinuation(answer, rejectionReason);
+        if (!plan) {
             return;
         }
-        const { state, interruption, emittedCommandIds: previouslyEmittedIds, toolCallArgumentsById, } = pendingApprovalContext;
-        const interruptionRecord = asRecord(interruption);
-        let removeInterceptor = null;
-        if (answer === 'y') {
-            this.logger.info('Tool approval granted', {
-                eventType: 'approval.granted',
-                category: 'approval',
-                phase: 'approval',
-                sessionId: this.id,
-                traceId: this.logger.getCorrelationId(),
-            });
-            const approve = getMethod(state, 'approve');
-            approve?.call(state, interruption);
-        }
-        else {
-            const toolName = getString(interruptionRecord, 'name') ?? 'unknown';
-            const expectedCallId = getCallIdFromObject(interruption);
-            const rejectionMessage = rejectionReason
-                ? `Tool execution was not approved. User's reason: ${rejectionReason}`
-                : 'Tool execution was not approved.';
-            if (typeof this.agentClient.addToolInterceptor === 'function') {
-                const removeInterceptor = this.agentClient.addToolInterceptor(async (name, _params, toolCallId) => {
-                    if (name === toolName && (!expectedCallId || toolCallId === expectedCallId)) {
-                        markToolCallAsApprovalRejection(toolCallId ?? expectedCallId);
-                        return rejectionMessage;
-                    }
-                    return null;
-                });
-                // Approve to continue but interceptor will return rejection message
-                const approve = getMethod(state, 'approve');
-                approve?.call(state, interruption);
-                // Store interceptor cleanup for after stream
-                this.approvalState.setPendingRemoveInterceptor(removeInterceptor);
-            }
-            else {
-                // Fallback for clients without tool interceptors
-                const reject = getMethod(state, 'reject');
-                reject?.call(state, interruption);
-            }
-            this.logger.info('Tool approval rejected', {
-                eventType: 'approval.rejected',
-                category: 'approval',
-                phase: 'approval',
-                sessionId: this.id,
-                traceId: this.logger.getCorrelationId(),
-            });
+        const { pendingApprovalContext: { state, toolCallArgumentsById, emittedCommandIds: previouslyEmittedIds }, toolStartedEvent, removeInterceptor, } = plan;
+        if (toolStartedEvent) {
+            yield toolStartedEvent;
         }
-        removeInterceptor = this.approvalState.getPending()?.removeInterceptor ?? null;
         // Restore cached tool-call arguments so continuation outputs can attach them
         this.toolCallArgumentsById.clear();
         if (toolCallArgumentsById?.size) {
@@ -428,34 +261,31 @@ export class ConversationSession {
             const stream = (await this.agentClient.continueRunStream(state, {
                 previousResponseId: this.previousResponseId,
             }));
-            const acc = {
-                finalOutput: '',
-                reasoningOutput: '',
-                emittedCommandIds: new Set(),
-                latestUsage: undefined,
-            };
-            yield* this.#streamEvents(stream, acc, {
+            const acc = createStreamAccumulator();
+            yield* processStreamEvents(stream, acc, {
+                toolCallArgumentsById: this.toolCallArgumentsById,
+                emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                 preserveExistingToolArgs: true,
-            });
+            }, { logger: this.logger, sessionId: this.id });
             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 result = this.#buildResult(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, allEmittedIds, acc.latestUsage);
-            if (result.type === 'approval_required') {
-                this.logger.info('Tool approval required', {
+            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: result.approval.toolName,
+                    toolName: resolvedResult.approval.toolName,
                 });
-                yield this.#toTerminalEvent(result);
+                yield toTerminalEvent(resolvedResult);
                 return;
             }
-            yield this.#toTerminalEvent(result);
+            yield toTerminalEvent(resolvedResult);
         }
         catch (error) {
             yield {
@@ -466,468 +296,112 @@ export class ConversationSession {
         }
         finally {
             // Clean up interceptor if one was added for rejection reason
-            removeInterceptor?.();
+            removeInterceptor();
         }
     }
-    async sendMessage(text, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, } = {}) {
-        let finalText = '';
-        let reasoningText = '';
-        const commandMessages = [];
-        let usage;
-        let sawTerminalEvent = null;
-        for await (const event of this.run(text, { hallucinationRetryCount })) {
-            onEvent?.(event);
-            switch (event.type) {
-                case 'text_delta': {
-                    const full = event.fullText ?? '';
-                    onTextChunk?.(full, event.delta);
-                    break;
-                }
-                case 'reasoning_delta': {
-                    const full = event.fullText ?? '';
-                    onReasoningChunk?.(full, event.delta);
-                    break;
-                }
-                case 'command_message': {
-                    onCommandMessage?.(event.message);
-                    break;
-                }
-                case 'approval_required': {
-                    sawTerminalEvent = event;
-                    // pendingApprovalContext is set inside #buildResult during run()
-                    const rawInterruption = this.approvalState.getPending()?.interruption;
-                    return {
-                        type: 'approval_required',
-                        approval: {
-                            agentName: event.approval.agentName,
-                            toolName: event.approval.toolName,
-                            argumentsText: event.approval.argumentsText,
-                            rawInterruption,
-                            callId: event.approval.callId,
-                        },
-                    };
-                }
-                case 'final': {
-                    sawTerminalEvent = event;
-                    finalText = event.finalText;
-                    reasoningText = event.reasoningText ?? '';
-                    usage = event.usage;
-                    this.logger.debug('sendMessage received final event', {
-                        sessionId: this.id,
-                        hasUsage: Boolean(event.usage),
-                        usage: event.usage,
-                    });
-                    if (event.commandMessages?.length) {
-                        for (const msg of event.commandMessages) {
-                            commandMessages.push(msg);
-                        }
-                    }
-                    break;
-                }
-                case 'error': {
-                    // Preserve legacy behavior (throwing) by throwing after the stream ends.
-                    break;
-                }
-                default:
-                    break;
-            }
-        }
-        // If we didn't see a terminal event, fall back to the legacy default.
-        if (!sawTerminalEvent) {
-            finalText = finalText || 'Done.';
-        }
-        const response = {
-            type: 'response',
-            commandMessages,
-            finalText: finalText || 'Done.',
-            ...(reasoningText ? { reasoningText } : {}),
-            ...(usage ? { usage } : {}),
-        };
-        this.logger.debug('sendMessage returning response', {
-            sessionId: this.id,
-            hasUsage: Boolean(usage),
-            usage,
+    async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, } = {}) {
+        const 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,
+                });
+            },
         });
-        return response;
+        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.approvalState.getPending()) {
+        if (!this.approvalFlow.getPending()) {
             return null;
         }
-        let finalText = '';
-        let reasoningText = '';
-        const commandMessages = [];
-        let usage;
-        let sawTerminalEvent = null;
-        for await (const event of this['continue']({ answer, rejectionReason })) {
-            onEvent?.(event);
-            switch (event.type) {
-                case 'text_delta': {
-                    const full = event.fullText ?? '';
-                    onTextChunk?.(full, event.delta);
-                    break;
-                }
-                case 'reasoning_delta': {
-                    const full = event.fullText ?? '';
-                    onReasoningChunk?.(full, event.delta);
-                    break;
-                }
-                case 'command_message': {
-                    onCommandMessage?.(event.message);
-                    break;
-                }
-                case 'approval_required': {
-                    sawTerminalEvent = event;
-                    const rawInterruption = this.approvalState.getPending()?.interruption;
-                    return {
-                        type: 'approval_required',
-                        approval: {
-                            agentName: event.approval.agentName,
-                            toolName: event.approval.toolName,
-                            argumentsText: event.approval.argumentsText,
-                            rawInterruption,
-                            callId: event.approval.callId,
-                        },
-                    };
-                }
-                case 'final': {
-                    sawTerminalEvent = event;
-                    finalText = event.finalText;
-                    reasoningText = event.reasoningText ?? '';
-                    usage = event.usage;
-                    this.logger.debug('handleApprovalDecision received final event', {
-                        sessionId: this.id,
-                        hasUsage: Boolean(event.usage),
-                        usage: event.usage,
-                    });
-                    if (event.commandMessages?.length) {
-                        for (const msg of event.commandMessages) {
-                            commandMessages.push(msg);
-                        }
-                    }
-                    break;
-                }
-                case 'error': {
-                    break;
-                }
-                default:
-                    break;
-            }
-        }
-        if (!sawTerminalEvent) {
-            const response = {
-                type: 'response',
-                commandMessages,
-                finalText: finalText || 'Done.',
-                ...(reasoningText ? { reasoningText } : {}),
-                ...(usage ? { usage } : {}),
-            };
+        const 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,
+                });
+            },
+        });
+        if (result.type === 'response') {
             this.logger.debug('handleApprovalDecision returning response', {
                 sessionId: this.id,
-                hasUsage: Boolean(usage),
-                usage,
+                hasUsage: Boolean(result.usage),
+                usage: result.usage,
             });
-            return response;
         }
-        const response = {
-            type: 'response',
-            commandMessages,
-            finalText: finalText || 'Done.',
-            ...(reasoningText ? { reasoningText } : {}),
-            ...(usage ? { usage } : {}),
-        };
-        this.logger.debug('handleApprovalDecision returning response', {
-            sessionId: this.id,
-            hasUsage: Boolean(usage),
+        return result;
+    }
+    async *#buildAndResolve(result, finalOutputOverride, reasoningOutputOverride, emittedCommandIds, usage) {
+        const outcome = await buildConversationResult({
+            result,
+            finalOutputOverride,
+            reasoningOutputOverride,
+            emittedCommandIds,
             usage,
+            toolCallArgumentsById: this.toolCallArgumentsById,
+        }, {
+            approvalFlow: this.approvalFlow,
+            shellAutoApproval: this.shellAutoApproval,
+            logger: this.logger,
+            sessionId: this.id,
         });
-        return response;
-    }
-    async *#streamEvents(stream, acc, { preserveExistingToolArgs }) {
-        const toolCallArgumentsById = this.toolCallArgumentsById;
-        if (!preserveExistingToolArgs) {
-            toolCallArgumentsById.clear();
+        if (outcome.kind !== 'auto_approve') {
+            return outcome.result;
         }
-        this.textDeltaCount = 0;
-        this.reasoningDeltaCount = 0;
-        const emitText = (delta) => {
-            if (!delta) {
-                return null;
-            }
-            acc.finalOutput += delta;
-            this.textDeltaCount++;
-            return {
-                type: 'text_delta',
-                delta,
-                fullText: acc.finalOutput,
-            };
-        };
-        const emitReasoning = (delta) => {
-            if (!delta || delta.replaceAll('\n', '') === '') {
-                return null;
-            }
-            acc.reasoningOutput += delta;
-            this.reasoningDeltaCount++;
-            return {
-                type: 'reasoning_delta',
-                delta,
-                fullText: acc.reasoningOutput,
-            };
-        };
-        for await (const rawEvent of stream) {
-            const event = asRecord(rawEvent);
-            const eventData = asRecord(event?.data);
-            const eventType = getString(event, 'type');
-            // Extract usage if present in any of the common locations.
-            // Check both the top-level event and event.data, since raw_model_stream_event
-            // nests response data (including usage) under .data (e.g. data.response.usage).
-            const usage = extractUsage(rawEvent) ?? (eventData ? extractUsage(eventData) : undefined);
-            if (usage) {
-                acc.latestUsage = usage;
-                this.logger.debug('Usage extracted from stream event', {
-                    sessionId: this.id,
-                    source: 'stream_event',
-                    eventType: eventType ?? getString(eventData, 'type') ?? 'unknown',
-                    usage,
-                });
-                // Emit usage update event for real-time token tracking
-                yield {
-                    type: 'usage_update',
-                    usage,
+        let finalText = '';
+        let reasoningText = '';
+        let finalUsage;
+        const commandMessages = [];
+        let approvalRequiredResult;
+        for await (const event of this['continue']({ answer: 'y' })) {
+            yield event;
+            if (event.type === 'approval_required') {
+                approvalRequiredResult = {
+                    type: 'approval_required',
+                    approval: {
+                        ...event.approval,
+                        rawInterruption: this.approvalFlow.getPendingInterruption(),
+                    },
                 };
             }
-            // Log event type with deduplication for ordering understanding
-            const delta1 = extractTextDelta(rawEvent);
-            if (delta1) {
-                const e = emitText(delta1);
-                if (e)
-                    yield e;
-            }
-            if (eventData) {
-                const delta2 = extractTextDelta(eventData);
-                if (delta2) {
-                    const e = emitText(delta2);
-                    if (e)
-                        yield e;
-                }
-            }
-            // Handle reasoning items
-            const reasoningDelta = extractReasoningDelta(rawEvent);
-            if (reasoningDelta) {
-                const e = emitReasoning(reasoningDelta);
-                if (e)
-                    yield e;
-            }
-            const maybeEmitCommandMessagesFromItems = (items) => emitCommandMessagesFromItems(items, {
-                toolCallArgumentsById,
-                emittedCommandIds: acc.emittedCommandIds,
-            });
-            if (eventType === 'run_item_stream_event') {
-                const eventItem = event?.item;
-                const eventItemRecord = asRecord(eventItem);
-                captureToolCallArguments(eventItem, toolCallArgumentsById);
-                // Emit tool_started event when a function_call is detected
-                const rawItem = asRecord(eventItemRecord?.rawItem) ?? eventItemRecord;
-                if (getString(rawItem, 'type') === 'function_call') {
-                    const callId = getString(rawItem, 'callId') ??
-                        getString(rawItem, 'call_id') ??
-                        getString(rawItem, 'tool_call_id') ??
-                        getString(rawItem, 'toolCallId') ??
-                        getString(rawItem, 'id');
-                    if (callId) {
-                        const toolName = getString(rawItem, 'name') ?? getString(eventItemRecord, 'name');
-                        const args = rawItem?.arguments ?? rawItem?.args ?? eventItemRecord?.arguments ?? eventItemRecord?.args;
-                        // Providers sometimes surface arguments as a JSON string.
-                        // Normalize here so downstream UI (pending/running display)
-                        // can reliably render parameters.
-                        const normalizedArgs = (() => {
-                            if (typeof args !== 'string') {
-                                return args;
-                            }
-                            const trimmed = args.trim();
-                            if (!trimmed) {
-                                return args;
-                            }
-                            try {
-                                return JSON.parse(trimmed);
-                            }
-                            catch {
-                                if ((trimmed.startsWith('{') || trimmed.startsWith('[')) &&
-                                    !this.emittedInvalidToolCallPackets.has(String(callId))) {
-                                    this.emittedInvalidToolCallPackets.add(String(callId));
-                                    const diagnostic = createInvalidToolCallDiagnostic({
-                                        toolName: toolName ?? 'unknown',
-                                        toolCallId: String(callId),
-                                        rawPayload: trimmed,
-                                        normalizedToolCall: {
-                                            toolName: toolName ?? 'unknown',
-                                            toolCallId: String(callId),
-                                            arguments: args,
-                                        },
-                                        validationErrors: ['arguments must be valid JSON'],
-                                        traceId: this.logger.getCorrelationId() ?? 'trace-unknown',
-                                        retryContext: {
-                                            sessionId: this.id,
-                                        },
-                                    });
-                                    this.logger.error('Invalid tool call argument payload', {
-                                        ...diagnostic,
-                                        sessionId: this.id,
-                                        messageId: String(callId),
-                                    });
-                                }
-                                return args;
-                            }
-                        })();
-                        yield {
-                            type: 'tool_started',
-                            toolCallId: callId,
-                            toolName: toolName ?? 'unknown',
-                            arguments: normalizedArgs,
-                        };
-                        this.logger.info('Tool execution started', {
-                            eventType: 'tool_call.execution_started',
-                            category: 'tool',
-                            phase: 'execution',
-                            sessionId: this.id,
-                            traceId: this.logger.getCorrelationId(),
-                            toolName: toolName ?? 'unknown',
-                            toolCallId: String(callId),
-                            messageId: String(callId),
-                        });
-                    }
-                }
-                for (const e of maybeEmitCommandMessagesFromItems([eventItem])) {
-                    yield e;
-                }
-            }
-            else if (eventType === 'tool_call_output_item' ||
-                getString(asRecord(event?.rawItem), 'type') === 'function_call_output') {
-                captureToolCallArguments(rawEvent, toolCallArgumentsById);
-                for (const e of maybeEmitCommandMessagesFromItems([rawEvent])) {
-                    yield e;
+            else if (event.type === 'final') {
+                finalText = event.finalText;
+                reasoningText = event.reasoningText ?? '';
+                finalUsage = event.usage;
+                if (event.commandMessages) {
+                    commandMessages.push(...event.commandMessages);
                 }
             }
         }
-        const completedResult = await stream.completed;
-        const rawResponses = Array.isArray(stream?.rawResponses) ? stream.rawResponses : [];
-        let usageFromRawResponses;
-        for (let i = rawResponses.length - 1; i >= 0; i--) {
-            const candidate = extractUsage(rawResponses[i]);
-            if (candidate) {
-                usageFromRawResponses = candidate;
-                break;
-            }
-        }
-        const finalUsage = extractUsage(completedResult) || extractUsage(stream) || usageFromRawResponses;
-        if (finalUsage) {
-            acc.latestUsage = finalUsage;
-            const usageSource = extractUsage(completedResult)
-                ? 'completed_result'
-                : extractUsage(stream)
-                    ? 'stream_object'
-                    : 'stream_raw_responses';
-            this.logger.debug('Usage extracted from stream completion', {
-                sessionId: this.id,
-                source: 'stream_completed',
-                usageSource,
-                usage: finalUsage,
-            });
-        }
-        else {
-            const completedResultRecord = completedResult && typeof completedResult === 'object' && !Array.isArray(completedResult)
-                ? completedResult
-                : undefined;
-            const streamRecord = stream && typeof stream === 'object' && !Array.isArray(stream)
-                ? stream
-                : undefined;
-            this.logger.debug('No usage found in stream completion', {
-                sessionId: this.id,
-                source: 'stream_completed',
-                completedResultType: completedResult === null ? 'null' : Array.isArray(completedResult) ? 'array' : typeof completedResult,
-                completedResultKeys: completedResultRecord ? Object.keys(completedResultRecord) : [],
-                streamKeys: streamRecord ? Object.keys(streamRecord) : [],
-                completedResultHasUsagePath: {
-                    usage: Boolean(completedResultRecord?.usage),
-                    usageMetadata: Boolean(completedResultRecord?.usageMetadata),
-                    usage_metadata: Boolean(completedResultRecord?.usage_metadata),
-                    responseUsage: Boolean(asRecord(completedResultRecord?.response)?.usage),
-                },
-            });
-        }
-    }
-    #toTerminalEvent(result) {
-        if (result.type === 'approval_required') {
-            return {
-                type: 'approval_required',
-                approval: {
-                    agentName: result.approval.agentName,
-                    toolName: result.approval.toolName,
-                    argumentsText: result.approval.argumentsText,
-                    ...(result.approval.callId ? { callId: result.approval.callId } : {}),
-                },
-            };
+        if (approvalRequiredResult) {
+            return approvalRequiredResult;
         }
         return {
-            type: 'final',
-            finalText: result.finalText,
-            ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
-            ...(result.commandMessages?.length ? { commandMessages: result.commandMessages } : {}),
-            ...(result.usage ? { usage: result.usage } : {}),
-        };
-    }
-    #buildResult(result, finalOutputOverride, reasoningOutputOverride, emittedCommandIds, usage) {
-        if (result.interruptions && result.interruptions.length > 0) {
-            const interruption = result.interruptions[0];
-            this.approvalState.setPending({
-                state: result.state,
-                interruption,
-                emittedCommandIds: emittedCommandIds ?? new Set(),
-                toolCallArgumentsById: new Map(this.toolCallArgumentsById),
-            });
-            let argumentsText = '';
-            const interruptionRecord = asRecord(interruption);
-            const toolName = getString(interruptionRecord, 'name');
-            // For shell_call (built-in shell tool), extract commands from action
-            // For function tools (bash, shell), extract from arguments
-            if (getString(interruptionRecord, 'type') === 'shell_call') {
-                const action = asRecord(interruptionRecord?.action);
-                const actionCommands = action?.commands;
-                if (actionCommands) {
-                    argumentsText = Array.isArray(actionCommands) ? actionCommands.join('\n') : String(actionCommands);
-                }
-            }
-            else {
-                argumentsText = getCommandFromArgs(interruptionRecord?.arguments);
-            }
-            const agent = asRecord(interruptionRecord?.agent);
-            const callId = getCallIdFromObject(interruption);
-            return {
-                type: 'approval_required',
-                approval: {
-                    agentName: getString(agent, 'name') ?? 'Agent',
-                    toolName: toolName ?? 'Unknown Tool',
-                    argumentsText,
-                    rawInterruption: interruption,
-                    ...(callId ? { callId: String(callId) } : {}),
-                },
-            };
-        }
-        this.approvalState.clearPending();
-        const allCommandMessages = extractCommandMessages(result.newItems || result.history || []);
-        // Filter out commands that were already emitted in real-time
-        const commandMessages = emittedCommandIds
-            ? allCommandMessages.filter((msg) => !emittedCommandIds.has(msg.id))
-            : allCommandMessages;
-        const visibleCommandMessages = commandMessages.filter((msg) => !msg.isApprovalRejection);
-        const response = {
             type: 'response',
-            commandMessages: visibleCommandMessages,
-            finalText: finalOutputOverride ?? result.finalOutput ?? 'Done.',
-            reasoningText: reasoningOutputOverride,
-            usage: usage ?? extractUsage(result),
+            commandMessages,
+            finalText: finalText || 'Done.',
+            ...(reasoningText ? { reasoningText } : {}),
+            ...(finalUsage ? { usage: finalUsage } : {}),
         };
-        return response;
     }
 }
 //# sourceMappingURL=conversation-session.js.map