@qduc/term2 0.9.2 → 0.9.3

package/dist/services/turn-execution-orchestrator.js

@@ -0,0 +1,687 @@
+import { getMaxTransientRetries, MAX_HALLUCINATION_RETRIES } from './conversation-retry-policy.js';
+import { getMethod, getCallIdFromObject } from './interruption-info.js';
+import { createStreamAccumulator, processStreamEvents } from './stream-event-processor.js';
+import { callIdOf, outputOf, reconcileHistoryWithToolLedger, toolNameOf } from './tool-execution-ledger.js';
+import { ChainingTransportDowngradeError } from '../providers/fallback-responses-model.js';
+import { describeError } from '../utils/error-helpers.js';
+import { normalizeUserTurn } from '../types/user-turn.js';
+import { toTerminalEvent } from './conversation-result-builder.js';
+const asArray = (value) => (Array.isArray(value) ? value : []);
+export class TurnExecutionOrchestrator {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async *run(input, { skipUserMessage = false, flexServiceTierFallbackCount = 0, hallucinationRetryCount = 0, transientRetryCount = 0, transportFallbackRetryCount = 0, maxModelRetries, signal, resumeState, } = {}) {
+        if (!skipUserMessage ||
+            hallucinationRetryCount > 0 ||
+            flexServiceTierFallbackCount > 0 ||
+            transientRetryCount > 0 ||
+            transportFallbackRetryCount > 0) {
+            this.host.resetTurnAccumulatorPersistedState();
+        }
+        const gen = this.host.getGeneration();
+        let stream = null;
+        let streamInput = '';
+        let inputSurgeKind = 'delta';
+        const turn = normalizeUserTurn(input);
+        const text = turn.text;
+        let addedUserMessage = false;
+        const ledgerSnapshot = this.host.toolLedger.export();
+        const maxTransientRetries = getMaxTransientRetries({
+            streamMaxRetries: getMethod(this.host.agentClient, 'getStreamMaxRetries')?.call(this.host.agentClient),
+        });
+        this.host.toolLedger.beginTurn();
+        let abortListener;
+        if (signal) {
+            if (signal.aborted) {
+                this.host.agentClient.abort();
+                throw Object.assign(new Error('Operation aborted'), { name: 'AbortError' });
+            }
+            abortListener = () => {
+                this.host.agentClient.abort();
+            };
+            signal.addEventListener('abort', abortListener);
+        }
+        try {
+            this.host.logger.debug('Conversation stream start', {
+                eventType: 'stream.started',
+                category: 'stream',
+                phase: 'request_start',
+                sessionId: this.host.id,
+                traceId: this.host.logger.getCorrelationId(),
+            });
+            const abortedContext = this.host.approvalFlow.consumeAborted();
+            const shouldAddUserMessage = !skipUserMessage && !abortedContext;
+            if (shouldAddUserMessage) {
+                this.host.conversationStore.addUserTurn(turn);
+                addedUserMessage = true;
+            }
+            else if (abortedContext && !skipUserMessage) {
+                yield { type: 'user_message_consumed_for_abort' };
+            }
+            if (abortedContext) {
+                this.host.logger.debug('Resolving aborted approval with fake execution', {
+                    message: text,
+                });
+                const { removeInterceptor } = this.host.approvalFlow.prepareAbortResolution(abortedContext, text);
+                try {
+                    const previousInputForSurge = this.host.getInputSurgeKind() === 'full_history' ? this.host.conversationStore.getHistory() : undefined;
+                    const continuedStream = (await this.host.agentClient.continueRunStream(abortedContext.state, {
+                        previousResponseId: this.host.getPreviousResponseId(),
+                        sessionId: this.host.id,
+                        toolResultCallIds: [getCallIdFromObject(abortedContext.interruption)].filter((callId) => typeof callId === 'string' && callId.length > 0),
+                    }));
+                    const acc = createStreamAccumulator();
+                    acc.emittedCommandIds = new Set(abortedContext.emittedCommandIds);
+                    for await (const event of processStreamEvents(continuedStream, acc, {
+                        toolCallArgumentsById: this.host.toolCallArgumentsById,
+                        emittedInvalidToolCallPackets: this.host.emittedInvalidToolCallPackets,
+                        preserveExistingToolArgs: true,
+                        onFunctionCallItem: (item) => this.host.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.host.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOf(item);
+                            if (cid && this.host.conversationLogger.hasSink()) {
+                                const entry = this.host.toolLedger.export().find((e) => e.callId === cid);
+                                this.host.conversationLogger.log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOf(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOf(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.host.logger, sessionId: this.host.id })) {
+                        const filtered = this.host.dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
+                    this.host.finalizeStreamOutcome(continuedStream, gen, 'abortResolution');
+                    if (continuedStream.interruptions && continuedStream.interruptions.length > 0) {
+                        this.host.logger.warn('Another interruption occurred after fake execution - handling as approval');
+                        const resolvedResult = yield* this.host.buildAndResolve(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                        this.host.recordInputSurgeSuccess(this.host.conversationStore.getHistory(), {
+                            kind: this.host.getInputSurgeKind(),
+                            previousInput: previousInputForSurge,
+                        });
+                        yield toTerminalEvent(resolvedResult);
+                        return;
+                    }
+                    this.host.logger.debug('Fake execution completed, agent received rejection message');
+                    const resolvedResult = yield* this.host.buildAndResolve(continuedStream, acc.finalOutput, acc.reasoningOutput, acc.emittedCommandIds, acc.latestUsage);
+                    this.host.recordInputSurgeSuccess(this.host.conversationStore.getHistory(), {
+                        kind: this.host.getInputSurgeKind(),
+                        previousInput: previousInputForSurge,
+                    });
+                    yield toTerminalEvent(resolvedResult);
+                    return;
+                }
+                catch (error) {
+                    this.host.logger.warn('Error resolving aborted approval with fake execution', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                finally {
+                    removeInterceptor();
+                }
+            }
+            ({ streamInput, inputSurgeKind } = this.host.buildOutgoingInput(turn, {
+                includeTurn: false,
+            }));
+            this.host.setInputSurgeKind(inputSurgeKind);
+            const surgeDecision = this.host.inputSurgeGuard.inspect(streamInput, { kind: inputSurgeKind });
+            if (surgeDecision.action === 'block') {
+                let droppedUserMessage;
+                if (addedUserMessage && this.host.isCurrentGeneration(gen)) {
+                    this.host.conversationStore.removeLastUserMessage();
+                    droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
+                }
+                this.host.logger.warn('Input surge guard blocked provider request', {
+                    eventType: 'input_surge.blocked',
+                    category: 'provider',
+                    phase: 'request_start',
+                    sessionId: this.host.id,
+                    traceId: this.host.logger.getCorrelationId(),
+                    reason: surgeDecision.reason,
+                    stats: surgeDecision.stats,
+                    previousStats: surgeDecision.previousStats,
+                });
+                yield {
+                    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;
+            }
+            if (this.host.getPendingModeNotice()) {
+                this.host.clearPendingModeNotice();
+            }
+            try {
+                if (resumeState && typeof this.host.agentClient.continueRunStream === 'function') {
+                    stream = (await this.host.agentClient.continueRunStream(resumeState, {
+                        previousResponseId: this.host.getPreviousResponseId(),
+                        sessionId: this.host.id,
+                    }));
+                }
+                else {
+                    stream = (await this.host.agentClient.startStream(streamInput, {
+                        previousResponseId: inputSurgeKind === 'delta' ? this.host.getPreviousResponseId() : null,
+                        sessionId: this.host.id,
+                    }));
+                }
+            }
+            catch (chainingError) {
+                if (chainingError instanceof ChainingTransportDowngradeError && this.host.allowFreshStartRetries) {
+                    this.host.breakChaining();
+                    this.host.logger.warn('ChainingTransportDowngradeError caught, retrying with full history', {
+                        eventType: 'retry.chaining_downgrade',
+                        category: 'retry',
+                        phase: 'retry',
+                        retryType: 'chaining_downgrade',
+                        sessionId: this.host.id,
+                        traceId: this.host.logger.getCorrelationId(),
+                        errorMessage: chainingError instanceof Error ? chainingError.message : String(chainingError),
+                    });
+                    const fullHistoryRetry = this.host.buildOutgoingInput(turn, { includeTurn: false });
+                    inputSurgeKind = fullHistoryRetry.inputSurgeKind;
+                    this.host.setInputSurgeKind(inputSurgeKind);
+                    stream = (await this.host.agentClient.startStream(fullHistoryRetry.streamInput, {
+                        previousResponseId: null,
+                        sessionId: this.host.id,
+                    }));
+                }
+                else {
+                    throw chainingError;
+                }
+            }
+            const acc = createStreamAccumulator();
+            for await (const event of processStreamEvents(stream, acc, {
+                toolCallArgumentsById: this.host.toolCallArgumentsById,
+                emittedInvalidToolCallPackets: this.host.emittedInvalidToolCallPackets,
+                preserveExistingToolArgs: false,
+                onFunctionCallItem: (item) => this.host.toolLedger.recordFunctionCall(item),
+                onFunctionResultItem: (item) => this.host.toolLedger.recordFunctionResult(item),
+            }, { logger: this.host.logger, sessionId: this.host.id })) {
+                const filtered = this.host.dedupeToolStarted(event);
+                if (filtered)
+                    yield filtered;
+            }
+            this.host.finalizeStreamOutcome(stream, gen, 'startStream');
+            const resolvedResult = yield* this.host.buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, acc.latestUsage);
+            this.host.recordInputSurgeSuccess(inputSurgeKind === 'delta' ? streamInput : this.host.conversationStore.getHistory(), inputSurgeKind === 'delta' ? { kind: inputSurgeKind } : { kind: inputSurgeKind, previousInput: streamInput });
+            if (resolvedResult.type === 'approval_required') {
+                if (resolvedResult.approval.callId) {
+                    this.host.toolLedger.recordFunctionCall({
+                        type: 'function_call',
+                        callId: resolvedResult.approval.callId,
+                        name: resolvedResult.approval.toolName,
+                        arguments: resolvedResult.approval.argumentsText,
+                    });
+                }
+                this.host.logger.debug('Tool approval required', {
+                    eventType: 'approval.required',
+                    category: 'approval',
+                    phase: 'approval',
+                    sessionId: this.host.id,
+                    traceId: this.host.logger.getCorrelationId(),
+                    toolName: resolvedResult.approval.toolName,
+                });
+                yield toTerminalEvent(resolvedResult);
+                return;
+            }
+            yield toTerminalEvent(resolvedResult);
+        }
+        catch (error) {
+            const streamHistoryLength = Array.isArray(stream?.history) ? stream.history.length : 0;
+            let decision = this.host.retryHandler.classifyError({
+                error,
+                transientRetryCount,
+                transportFallbackRetryCount,
+                hallucinationRetryCount,
+                flexServiceTierFallbackCount,
+                maxTransientRetries,
+                stream,
+                streamHistoryLength,
+                maxModelRetries,
+            });
+            if (!this.host.allowFreshStartRetries &&
+                !stream &&
+                decision.kind !== 'none' &&
+                decision.kind !== 'unrecoverable') {
+                this.host.logger.warn('Retry requires fresh start but fresh-start retries are disabled for this session', {
+                    eventType: 'retry.fresh_start_blocked',
+                    category: 'retry',
+                    phase: 'retry',
+                    sessionId: this.host.id,
+                    traceId: this.host.logger.getCorrelationId(),
+                    retryKind: decision.kind,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                });
+                decision = { kind: 'unrecoverable' };
+            }
+            switch (decision.kind) {
+                case 'flex_fallback': {
+                    this.host.logger.warn('Flex service tier timed out, retrying with standard service tier', {
+                        eventType: 'retry.flex_service_tier',
+                        category: 'retry',
+                        phase: 'retry',
+                        retryType: 'flex_service_tier',
+                        retryAttempt: 1,
+                        attempt: 1,
+                        maxRetries: 1,
+                        sessionId: this.host.id,
+                        traceId: this.host.logger.getCorrelationId(),
+                        errorMessage: error instanceof Error ? error.message : String(error),
+                    });
+                    yield {
+                        type: 'retry',
+                        toolName: 'service_tier',
+                        attempt: 1,
+                        maxRetries: 1,
+                        errorMessage: 'Flex service tier timed out. Falling back to standard service tier and retrying.',
+                        retryType: 'flex_service_tier',
+                    };
+                    getMethod(this.host.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.host.agentClient);
+                    this.host.retryHandler.restoreForRetry({
+                        ledgerSnapshot,
+                        stream,
+                        toolLedger: this.host.toolLedger,
+                        conversationStore: this.host.conversationStore,
+                        clearPreviousResponseId: () => {
+                            this.host.setPreviousResponseId(null);
+                        },
+                        restoreCompletedToolLedgerEntries: (snapshot) => this.host.restoreCompletedToolLedgerEntries(snapshot),
+                    });
+                    yield* this.run(turn, {
+                        skipUserMessage: true,
+                        flexServiceTierFallbackCount: flexServiceTierFallbackCount + 1,
+                        maxModelRetries,
+                    });
+                    return;
+                }
+                case 'transient': {
+                    this.host.logger.warn('Transient upstream error detected, retrying turn', {
+                        eventType: 'retry.transient',
+                        category: 'retry',
+                        phase: 'retry',
+                        retryType: 'upstream',
+                        retryAttempt: decision.attempt,
+                        attempt: decision.attempt,
+                        maxRetries: maxTransientRetries,
+                        sessionId: this.host.id,
+                        traceId: this.host.logger.getCorrelationId(),
+                        errorMessage: error instanceof Error ? error.message : String(error),
+                        delayMs: decision.delay,
+                    });
+                    const isResuming = Boolean(stream?.state && typeof this.host.agentClient.continueRunStream === 'function');
+                    yield {
+                        type: 'retry',
+                        toolName: isResuming ? 'continuation' : 'turn',
+                        attempt: decision.attempt,
+                        maxRetries: maxTransientRetries,
+                        errorMessage: error instanceof Error ? error.message : String(error),
+                        retryType: 'upstream',
+                    };
+                    if (!this.host.isCurrentGeneration(gen))
+                        return;
+                    if (!isResuming) {
+                        this.host.retryHandler.restoreForRetry({
+                            ledgerSnapshot,
+                            stream,
+                            toolLedger: this.host.toolLedger,
+                            conversationStore: this.host.conversationStore,
+                            clearPreviousResponseId: () => {
+                                this.host.setPreviousResponseId(null);
+                            },
+                            restoreCompletedToolLedgerEntries: (snapshot) => this.host.restoreCompletedToolLedgerEntries(snapshot),
+                            removeLastUserMessage: () => this.host.conversationStore.removeLastUserMessage(),
+                        });
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, decision.delay));
+                    yield* this.run(turn, {
+                        skipUserMessage: Boolean(stream),
+                        transientRetryCount: decision.attempt,
+                        transportFallbackRetryCount,
+                        maxModelRetries,
+                        resumeState: isResuming ? stream?.state : undefined,
+                    });
+                    return;
+                }
+                case 'transport_downgrade': {
+                    const attempt = transportFallbackRetryCount + 1;
+                    this.host.logger.warn('Transient upstream error exhausted WS retries, forcing HTTP fallback', {
+                        eventType: 'retry.transport_fallback',
+                        category: 'retry',
+                        phase: 'retry',
+                        retryType: 'upstream',
+                        retryAttempt: attempt,
+                        attempt,
+                        maxRetries: 1,
+                        sessionId: this.host.id,
+                        traceId: this.host.logger.getCorrelationId(),
+                        errorMessage: error instanceof Error ? error.message : String(error),
+                    });
+                    yield {
+                        type: 'retry',
+                        toolName: 'transport',
+                        attempt,
+                        maxRetries: 1,
+                        errorMessage: 'WebSocket retries exhausted. Falling back to HTTP transport and retrying.',
+                        retryType: 'upstream',
+                    };
+                    if (!this.host.isCurrentGeneration(gen))
+                        return;
+                    this.host.retryHandler.restoreForRetry({
+                        ledgerSnapshot,
+                        stream,
+                        toolLedger: this.host.toolLedger,
+                        conversationStore: this.host.conversationStore,
+                        clearPreviousResponseId: () => {
+                            this.host.setPreviousResponseId(null);
+                        },
+                        restoreCompletedToolLedgerEntries: (snapshot) => this.host.restoreCompletedToolLedgerEntries(snapshot),
+                        removeLastUserMessage: () => this.host.conversationStore.removeLastUserMessage(),
+                    });
+                    yield* this.run(turn, {
+                        skipUserMessage: Boolean(stream),
+                        transientRetryCount: 0,
+                        transportFallbackRetryCount: attempt,
+                        maxModelRetries,
+                    });
+                    return;
+                }
+                case 'hallucination': {
+                    const decisionResult = decision.decision;
+                    if (decisionResult.kind !== 'retry') {
+                        break;
+                    }
+                    this.host.logger.warn('Recoverable model error detected, retrying', {
+                        eventType: 'retry.model_error',
+                        category: 'retry',
+                        phase: 'retry',
+                        toolName: decisionResult.logPayload.toolName,
+                        retryType: decisionResult.logPayload.retryType,
+                        retryAttempt: decisionResult.attempt,
+                        attempt: decisionResult.attempt,
+                        maxRetries: maxModelRetries ?? MAX_HALLUCINATION_RETRIES,
+                        sessionId: this.host.id,
+                        traceId: this.host.logger.getCorrelationId(),
+                        errorMessage: decisionResult.message,
+                    });
+                    yield decisionResult.retryEvent;
+                    if (!this.host.isCurrentGeneration(gen))
+                        return;
+                    if (decisionResult.hadStream && stream) {
+                        this.host.toolLedger.import(ledgerSnapshot);
+                        if (decisionResult.shouldInjectErrorContext) {
+                            this.host.conversationStore.addErrorContext(decisionResult.errorContextMessage);
+                        }
+                    }
+                    else {
+                        this.host.conversationStore.removeLastUserMessage();
+                    }
+                    yield* this.run(turn, {
+                        ...decisionResult.nextRunOptions,
+                        maxModelRetries,
+                    });
+                    return;
+                }
+                case 'none':
+                case 'unrecoverable':
+                    break;
+            }
+            let droppedUserMessage;
+            if (addedUserMessage && !stream && this.host.isCurrentGeneration(gen)) {
+                this.host.conversationStore.removeLastUserMessage();
+                droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
+            }
+            if (stream && this.host.isCurrentGeneration(gen)) {
+                this.host.toolLedger.markOpenCallsAborted(error instanceof Error ? error.message : String(error));
+                const reconciled = reconcileHistoryWithToolLedger(this.host.conversationStore.getHistory(), this.host.toolLedger.export());
+                if (reconciled.addedCompletedPairs > 0 || reconciled.droppedIncompleteCalls > 0) {
+                    this.host.conversationStore.replaceHistory(reconciled.history);
+                }
+                this.host.recordInputSurgeSuccess(this.host.conversationStore.getHistory(), {
+                    kind: 'full_history',
+                    previousInput: streamInput,
+                });
+                const recoverySummary = this.host.toolLedger.getRecoverySummary();
+                if (recoverySummary) {
+                    yield {
+                        type: 'tool_recovery',
+                        recoveredCallIds: recoverySummary.recoveredCallIds,
+                        droppedCallIds: recoverySummary.droppedCallIds,
+                        message: recoverySummary.message,
+                    };
+                }
+            }
+            yield {
+                type: 'error',
+                message: describeError(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+                ...(droppedUserMessage ? { droppedUserMessage } : {}),
+            };
+            this.host.logger.error('Conversation stream error', {
+                eventType: 'stream.failed',
+                category: 'stream',
+                phase: 'abort',
+                sessionId: this.host.id,
+                traceId: this.host.logger.getCorrelationId(),
+                errorMessage: describeError(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+        finally {
+            if (signal && abortListener) {
+                signal.removeEventListener('abort', abortListener);
+            }
+        }
+    }
+    async *continueApproval({ answer, rejectionReason, }) {
+        const gen = this.host.getGeneration();
+        const plan = this.host.approvalFlow.prepareContinuation(answer, rejectionReason);
+        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.host.toolLedger.recordAbortedApproval(output, output, callId);
+        }
+        const { pendingApprovalContext: { state, interruption, toolCallArgumentsById, emittedCommandIds: previouslyEmittedIds }, toolStartedEvent, removeInterceptor, } = plan;
+        const ledgerSnapshot = this.host.toolLedger.export();
+        const approvedToolResultCallIds = [getCallIdFromObject(interruption)].filter((callId) => typeof callId === 'string' && callId.length > 0);
+        let stream = null;
+        if (toolStartedEvent) {
+            const filtered = this.host.dedupeToolStarted(toolStartedEvent);
+            if (filtered)
+                yield filtered;
+        }
+        this.host.toolCallArgumentsById.clear();
+        if (toolCallArgumentsById?.size) {
+            for (const [key, value] of toolCallArgumentsById.entries()) {
+                this.host.toolCallArgumentsById.set(key, value);
+            }
+        }
+        try {
+            let transientRetryCount = 0;
+            while (true) {
+                try {
+                    const previousInputForSurge = this.host.getInputSurgeKind() === 'full_history' ? this.host.conversationStore.getHistory() : undefined;
+                    stream = (await this.host.agentClient.continueRunStream(state, {
+                        previousResponseId: this.host.getPreviousResponseId(),
+                        sessionId: this.host.id,
+                        toolResultCallIds: approvedToolResultCallIds,
+                    }));
+                    const acc = createStreamAccumulator();
+                    for await (const event of processStreamEvents(stream, acc, {
+                        toolCallArgumentsById: this.host.toolCallArgumentsById,
+                        emittedInvalidToolCallPackets: this.host.emittedInvalidToolCallPackets,
+                        preserveExistingToolArgs: true,
+                        onFunctionCallItem: (item) => this.host.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.host.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOf(item);
+                            if (cid && this.host.conversationLogger.hasSink()) {
+                                const entry = this.host.toolLedger.export().find((e) => e.callId === cid);
+                                this.host.conversationLogger.log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOf(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOf(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.host.logger, sessionId: this.host.id })) {
+                        const filtered = this.host.dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
+                    this.host.finalizeStreamOutcome(stream, gen, 'continueRunStream');
+                    const allEmittedIds = new Set([...previouslyEmittedIds, ...acc.emittedCommandIds]);
+                    const resolvedResult = yield* this.host.buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, allEmittedIds, acc.latestUsage);
+                    if (resolvedResult.type === 'approval_required') {
+                        if (resolvedResult.approval.callId) {
+                            this.host.toolLedger.recordFunctionCall({
+                                type: 'function_call',
+                                callId: resolvedResult.approval.callId,
+                                name: resolvedResult.approval.toolName,
+                                arguments: resolvedResult.approval.argumentsText,
+                            });
+                        }
+                        this.host.logger.debug('Tool approval required', {
+                            eventType: 'approval.required',
+                            category: 'approval',
+                            phase: 'approval',
+                            sessionId: this.host.id,
+                            traceId: this.host.logger.getCorrelationId(),
+                            toolName: resolvedResult.approval.toolName,
+                        });
+                        this.host.recordInputSurgeSuccess(this.host.conversationStore.getHistory(), {
+                            kind: this.host.getInputSurgeKind(),
+                            previousInput: previousInputForSurge,
+                        });
+                        yield toTerminalEvent(resolvedResult);
+                        return;
+                    }
+                    this.host.recordInputSurgeSuccess(this.host.conversationStore.getHistory(), {
+                        kind: this.host.getInputSurgeKind(),
+                        previousInput: previousInputForSurge,
+                    });
+                    yield toTerminalEvent(resolvedResult);
+                    return;
+                }
+                catch (error) {
+                    const maxTransientRetries = getMaxTransientRetries({
+                        streamMaxRetries: getMethod(this.host.agentClient, 'getStreamMaxRetries')?.call(this.host.agentClient),
+                    });
+                    const decision = this.host.retryHandler.classifyError({
+                        error,
+                        transientRetryCount,
+                        transportFallbackRetryCount: 0,
+                        hallucinationRetryCount: 0,
+                        flexServiceTierFallbackCount: 0,
+                        maxTransientRetries,
+                        stream,
+                        streamHistoryLength: Array.isArray(stream?.history) ? stream.history.length : 0,
+                    });
+                    if (!this.host.allowFreshStartRetries &&
+                        !stream &&
+                        decision.kind !== 'none' &&
+                        decision.kind !== 'unrecoverable') {
+                        this.host.logger.warn('Retry requires fresh start but fresh-start retries are disabled for this session', {
+                            eventType: 'retry.fresh_start_blocked',
+                            category: 'retry',
+                            phase: 'retry',
+                            sessionId: this.host.id,
+                            traceId: this.host.logger.getCorrelationId(),
+                            retryKind: decision.kind,
+                            errorMessage: error instanceof Error ? error.message : String(error),
+                        });
+                        throw error;
+                    }
+                    if (decision.kind === 'transient') {
+                        transientRetryCount = decision.attempt;
+                        this.host.logger.warn('Transient error in continuation, retrying', {
+                            eventType: 'retry.transient',
+                            category: 'retry',
+                            phase: 'retry',
+                            retryType: 'upstream',
+                            retryAttempt: transientRetryCount,
+                            maxRetries: maxTransientRetries,
+                            sessionId: this.host.id,
+                            traceId: this.host.logger.getCorrelationId(),
+                            errorMessage: error instanceof Error ? error.message : String(error),
+                            delayMs: decision.delay,
+                        });
+                        yield {
+                            type: 'retry',
+                            toolName: 'continuation',
+                            attempt: transientRetryCount,
+                            maxRetries: maxTransientRetries,
+                            errorMessage: error instanceof Error ? error.message : String(error),
+                            retryType: 'upstream',
+                        };
+                        await new Promise((resolve) => setTimeout(resolve, decision.delay));
+                        if (!this.host.isCurrentGeneration(gen))
+                            return;
+                        if (!stream) {
+                            this.host.recoverApprovedToolResultsFromState(state, approvedToolResultCallIds);
+                            this.host.retryHandler.restoreForRetry({
+                                ledgerSnapshot,
+                                stream,
+                                toolLedger: this.host.toolLedger,
+                                conversationStore: this.host.conversationStore,
+                                clearPreviousResponseId: () => {
+                                    this.host.setPreviousResponseId(null);
+                                },
+                                restoreCompletedToolLedgerEntries: (snapshot) => this.host.restoreCompletedToolLedgerEntries(snapshot),
+                            });
+                            const lastUserText = this.host.conversationStore.getLastUserMessage();
+                            const dummyTurn = { text: lastUserText };
+                            yield* this.run(dummyTurn, {
+                                skipUserMessage: true,
+                                transientRetryCount,
+                            });
+                            return;
+                        }
+                        this.host.toolLedger.import(ledgerSnapshot);
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            this.host.logger.error('Conversation stream error during continuation', {
+                eventType: 'stream.failed',
+                category: 'stream',
+                phase: 'abort',
+                sessionId: this.host.id,
+                traceId: this.host.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;
+        }
+        finally {
+            removeInterceptor();
+        }
+    }
+}
+//# sourceMappingURL=turn-execution-orchestrator.js.map