@qduc/term2 0.9.0 → 0.9.2

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

@@ -1,687 +0,0 @@
-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