@qduc/term2 0.9.1 → 0.9.3

package/dist/services/session/turn-workflow.js

@@ -0,0 +1,648 @@
+import { TurnAttempt } from './turn-attempt.js';
+import { getMethod, getCallIdFromObject, asRecord, getToolInfoFromInterruption } from '../interruption-info.js';
+import { ShellAutoApprovalDecisionPolicy } from '../approval/approval-decision-policy.js';
+import { describeError } from '../../utils/error-helpers.js';
+import { callIdOf } from '../tool-execution-ledger.js';
+import { ContinuationState } from './continuation-state.js';
+import { ToolApprovalBatchCoordinator } from '../approval/tool-approval-batch-coordinator.js';
+import { createApprovalRequiredTerminal, buildConversationResult, } from '../conversation/conversation-result-builder.js';
+import { extractCommandMessages } from '../../utils/streaming/extract-command-messages.js';
+export class TurnWorkflow {
+    deps;
+    #batchCoordinator;
+    constructor(deps) {
+        this.deps = deps;
+        this.#batchCoordinator =
+            deps.batchCoordinator ??
+                new ToolApprovalBatchCoordinator({
+                    approvalFlow: deps.approvalFlow,
+                    planApplier: deps.planApplier,
+                    shellAutoApproval: deps.shellAutoApproval,
+                    logger: deps.logger,
+                    sessionId: deps.sessionId,
+                    isCurrent: (token) => deps.generationGuard.isCurrent(token),
+                });
+    }
+    async *executeInitial(attemptOrInput, options = {}) {
+        let currentInput = attemptOrInput;
+        let currentOptions = options;
+        while (true) {
+            const initialOutcome = yield* this.executeInitialAttempt(currentInput, currentOptions);
+            if (initialOutcome.kind !== 'abort_resolution_required' && initialOutcome.kind !== 'auto_approval_required') {
+                return initialOutcome;
+            }
+            const generation = initialOutcome.generation;
+            let driveResult;
+            if (initialOutcome.kind === 'abort_resolution_required') {
+                driveResult = yield* this.executeContinuationAttempt({
+                    kind: 'abort_resolution',
+                    abortedContext: initialOutcome.abortedContext,
+                    userText: initialOutcome.userText,
+                    generation,
+                }, new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval));
+            }
+            else {
+                driveResult = yield* this.executeContinuationAttempt({
+                    kind: 'approval_decision',
+                    answer: 'y',
+                    generation,
+                }, new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval));
+            }
+            if (driveResult.kind !== 'fresh_start_required') {
+                return driveResult;
+            }
+            currentInput = { text: '' };
+            currentOptions = {
+                skipUserMessage: true,
+                retries: driveResult.retryCounts,
+                delayMs: driveResult.delayMs,
+                useStandardServiceTier: driveResult.useStandardServiceTier,
+                token: generation,
+                replayFromHistory: true,
+            };
+        }
+    }
+    async *executeContinuation(init, policy) {
+        const driveResult = yield* this.executeContinuationAttempt(init, policy);
+        if (driveResult.kind !== 'fresh_start_required') {
+            return driveResult;
+        }
+        return yield* this.#replayFromFreshStart(init.generation, driveResult);
+    }
+    #freshStartReplayOptions(generation, result) {
+        return {
+            skipUserMessage: true,
+            retries: result.retryCounts,
+            delayMs: result.delayMs,
+            useStandardServiceTier: result.useStandardServiceTier,
+            token: generation,
+            replayFromHistory: true,
+        };
+    }
+    async *#replayFromFreshStart(generation, result) {
+        return yield* this.executeInitial({ text: '' }, this.#freshStartReplayOptions(generation, result));
+    }
+    async *executeInitialAttempt(attemptOrInput, options = {}) {
+        let attempt;
+        if (attemptOrInput instanceof TurnAttempt) {
+            attempt = attemptOrInput;
+        }
+        else {
+            const creation = this.deps.attemptFactory.create(attemptOrInput, options);
+            if (creation.kind === 'stale') {
+                return { kind: 'stale' };
+            }
+            attempt = creation.attempt;
+        }
+        let skipUser = options.skipUserMessage ?? false;
+        let currentResumeState = options.resumeState;
+        let currentResumePreviousResponseId = options.resumePreviousResponseId;
+        let currentAbortedContext = options.abortedContext ?? null;
+        const initialCounts = attempt.retryCounts;
+        if (options.replayFromHistory ||
+            !skipUser ||
+            initialCounts.modelRetryCount > 0 ||
+            initialCounts.serviceTierFallbackCount > 0 ||
+            initialCounts.transientRetryCount > 0 ||
+            initialCounts.transportDowngradeCount > 0) {
+            this.deps.turnAccumulator.resetPersistedTurnState();
+        }
+        try {
+            if (options.delayMs && options.delayMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, options.delayMs));
+            }
+            if (!this.deps.generationGuard.isCurrent(attempt.token)) {
+                return { kind: 'stale' };
+            }
+            if (options.useStandardServiceTier) {
+                getMethod(this.deps.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.deps.agentClient);
+            }
+            this.deps.toolTracker.ledger.beginTurn();
+            this.deps.journal.resetForNewTurn();
+            while (true) {
+                // 1. Check generation token validity
+                if (currentAbortedContext) {
+                    const tokenVal = currentAbortedContext.token ?? 0;
+                    if (!this.deps.generationGuard.isCurrent(tokenVal)) {
+                        return { kind: 'stale' };
+                    }
+                }
+                else {
+                    if (!this.deps.generationGuard.isCurrent(attempt.token)) {
+                        return { kind: 'stale' };
+                    }
+                }
+                // 2. Handle aborted-approval resolution
+                if (currentAbortedContext) {
+                    // Preserve the follow-up prompt as a normal user turn so the next
+                    // turn can steer the conversation naturally after an ESC abort.
+                    const preparation = this.deps.inputPreparer.prepare(attempt, skipUser, {
+                        bypassInputSurgeGuard: true,
+                        replayFromHistory: options.replayFromHistory,
+                    });
+                    if (preparation.kind === 'blocked') {
+                        yield preparation.event;
+                        return { kind: 'failed' };
+                    }
+                    this.deps.logger.debug('Resolving aborted approval with fake execution', {
+                        message: attempt.turn.text,
+                    });
+                    return {
+                        kind: 'abort_resolution_required',
+                        abortedContext: currentAbortedContext,
+                        userText: attempt.turn.text,
+                        generation: attempt.token,
+                    };
+                }
+                const preparation = this.deps.inputPreparer.prepare(attempt, skipUser, options);
+                if (preparation.kind === 'blocked') {
+                    yield preparation.event;
+                    return { kind: 'failed' };
+                }
+                try {
+                    const cycleResult = yield* this.#executeInitialStreamCycle(attempt, {
+                        resumeState: currentResumeState,
+                        resumePreviousResponseId: currentResumePreviousResponseId,
+                    });
+                    if (cycleResult.kind === 'stale') {
+                        return { kind: 'stale' };
+                    }
+                    const { outcome } = cycleResult;
+                    if (outcome.kind === 'response') {
+                        return { kind: 'response', terminal: outcome.result };
+                    }
+                    if (outcome.kind === 'auto_approve') {
+                        this.deps.logger.debug('Shell command auto-approved by LLM', {
+                            eventType: 'approval.auto_approved',
+                            category: 'approval',
+                            phase: 'approval',
+                            sessionId: this.deps.sessionId,
+                            traceId: this.deps.logger.getCorrelationId(),
+                            callId: outcome.callId,
+                            command: outcome.argumentsText,
+                            model: outcome.advisory?.model,
+                            reasoning: outcome.advisory?.reasoning,
+                        });
+                        return {
+                            kind: 'auto_approval_required',
+                            generation: attempt.token,
+                            callId: outcome.callId,
+                            command: outcome.argumentsText,
+                        };
+                    }
+                    if (outcome.result.approval.callId) {
+                        this.deps.toolTracker.recordFunctionCall({
+                            type: 'function_call',
+                            callId: outcome.result.approval.callId,
+                            name: outcome.result.approval.toolName,
+                            arguments: outcome.result.approval.argumentsText,
+                        });
+                    }
+                    this.deps.logger.debug('Tool approval required', {
+                        eventType: 'approval.required',
+                        category: 'approval',
+                        phase: 'approval',
+                        sessionId: this.deps.sessionId,
+                        traceId: this.deps.logger.getCorrelationId(),
+                        toolName: outcome.result.approval.toolName,
+                    });
+                    return { kind: 'approval_required', terminal: outcome.result };
+                }
+                catch (error) {
+                    const handled = yield* this.deps.recoveryHandler.handle({
+                        error,
+                        attempt,
+                        stream: attempt.stream,
+                    });
+                    if (handled.kind === 'run') {
+                        skipUser = handled.instruction.skipUserMessage;
+                        currentResumeState = handled.instruction.resumeState;
+                        currentResumePreviousResponseId = handled.instruction.resumePreviousResponseId;
+                        currentAbortedContext = null;
+                        if (handled.delayMs && handled.delayMs > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, handled.delayMs));
+                        }
+                        if (handled.useStandardServiceTier) {
+                            getMethod(this.deps.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.deps.agentClient);
+                        }
+                        continue;
+                    }
+                    else if (handled.kind === 'stale') {
+                        return { kind: 'stale' };
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+        finally {
+            attempt.close();
+        }
+    }
+    async *#executeInitialStreamCycle(attempt, options) {
+        const stream = await this.#startInitialStream(attempt, options);
+        attempt.attachStream(stream);
+        const accumulated = yield* this.deps.streamProcessor.process(stream, {
+            gen: attempt.token,
+            source: 'startStream',
+            preserveExistingToolArgs: false,
+        });
+        const finalized = this.deps.streamProcessor.finalize(stream, attempt.token, attempt.inputMode, 'startStream');
+        if (finalized.kind === 'stale') {
+            return { kind: 'stale' };
+        }
+        const outcome = await buildConversationResult({
+            result: stream,
+            finalOutputOverride: accumulated.finalOutput || undefined,
+            reasoningOutputOverride: accumulated.reasoningOutput || undefined,
+            emittedCommandIds: accumulated.emittedCommandIds,
+            usage: accumulated.latestUsage,
+            toolCallArgumentsById: this.deps.toolTracker.argumentsById,
+            turnItems: this.deps.turnAccumulator.getTurnItems(),
+            token: attempt.token,
+            inputMode: attempt.inputMode,
+        }, {
+            approvalFlow: this.deps.approvalFlow,
+            shellAutoApproval: this.deps.shellAutoApproval,
+            logger: this.deps.logger,
+            sessionId: this.deps.sessionId,
+        });
+        this.deps.inputPlanner.recordSuccess(attempt.inputMode === 'delta' ? attempt.streamInput : this.deps.conversationStore.getHistory(), attempt.inputMode === 'delta'
+            ? { kind: attempt.inputMode }
+            : { kind: attempt.inputMode, previousInput: attempt.streamInput });
+        return { kind: 'completed', outcome };
+    }
+    async #startInitialStream(attempt, options) {
+        if (options.resumeState && typeof this.deps.agentClient.continueRunStream === 'function') {
+            return (await this.deps.agentClient.continueRunStream(options.resumeState, {
+                previousResponseId: options.resumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
+                sessionId: this.deps.sessionId,
+            }));
+        }
+        return (await this.deps.agentClient.startStream(attempt.streamInput, {
+            previousResponseId: attempt.inputMode === 'delta' ? this.deps.providerContinuity.previousResponseId : null,
+            sessionId: this.deps.sessionId,
+        }));
+    }
+    async *executeContinuationAttempt(init, policy) {
+        const activePolicy = policy ?? new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval);
+        if (!this.deps.generationGuard.isCurrent(init.generation)) {
+            return { kind: 'stale' };
+        }
+        const prepared = this.deps.planApplier.prepareInit(init);
+        const state = new ContinuationState(init.generation);
+        state.initializeFrom(prepared, this.#activeCallIdsForInit(init, prepared));
+        try {
+            yield* this.deps.planApplier.applyInitialSetup(prepared, state);
+            while (true) {
+                if (!this.deps.generationGuard.isCurrent(state.token)) {
+                    return { kind: 'stale' };
+                }
+                try {
+                    const batchDecision = yield* this.#stagePendingParallelApprovals(state, activePolicy);
+                    if (batchDecision.kind === 'stale') {
+                        return { kind: 'stale' };
+                    }
+                    if (batchDecision.kind === 'approval_required') {
+                        return { kind: 'approval_required', terminal: batchDecision.terminal };
+                    }
+                    const previousInputForSurge = state.inputMode === 'full_history' ? this.deps.conversationStore.getHistory() : undefined;
+                    const cycleResult = yield* this.#executeContinuationStreamCycle(state);
+                    if (cycleResult.kind === 'stale') {
+                        return { kind: 'stale' };
+                    }
+                    const { outcome, nextCumulativeMessages, nextCumulativeUsage, nextCumulativeTurnItems, mergedEmittedIds } = cycleResult;
+                    state.setCumulativeUsage(nextCumulativeUsage);
+                    state.setCumulativeCommandMessages(nextCumulativeMessages);
+                    state.setCumulativeTurnItems(nextCumulativeTurnItems);
+                    if (outcome.kind === 'response') {
+                        this.#recordSuccess(state, previousInputForSurge);
+                        return { kind: 'response', terminal: this.#buildResponse(outcome.result, nextCumulativeUsage) };
+                    }
+                    const approvalResult = await this.#handleApprovalOutcome(outcome, state, activePolicy, nextCumulativeUsage, previousInputForSurge);
+                    if (approvalResult.action === 'return') {
+                        return approvalResult.result;
+                    }
+                    if (approvalResult.action === 'loop') {
+                        yield* this.deps.planApplier.applyNextPlan(approvalResult.nextPlan, state, mergedEmittedIds, approvalResult.isApproved);
+                        state.currentCallIds = this.#activeCallIdsForResponseCycle(approvalResult.nextPlan.pendingApprovalContext.state, approvalResult.nextPlan.pendingApprovalContext.interruption, state.currentCallIds);
+                    }
+                    continue;
+                }
+                catch (error) {
+                    const recovery = yield* this.#handleContinuationRecovery(error, state);
+                    if (recovery.kind === 'terminated') {
+                        throw error;
+                    }
+                    if (recovery.kind === 'stale') {
+                        return { kind: 'stale' };
+                    }
+                    if (recovery.kind === 'fresh_start') {
+                        return {
+                            kind: 'fresh_start_required',
+                            retryCounts: recovery.retryCounts,
+                            ...(recovery.delayMs !== undefined ? { delayMs: recovery.delayMs } : {}),
+                            ...(recovery.useStandardServiceTier ? { useStandardServiceTier: true } : {}),
+                        };
+                    }
+                    // recovery.kind === 'resume' -> continue loop
+                }
+            }
+        }
+        catch (error) {
+            this.deps.logger.error('Conversation stream error during continuation', {
+                eventType: 'stream.failed',
+                category: 'stream',
+                phase: 'abort',
+                sessionId: this.deps.sessionId,
+                traceId: this.deps.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 {
+            prepared.removeInterceptor();
+        }
+    }
+    async *#stagePendingParallelApprovals(state, activePolicy) {
+        const result = yield* this.#batchCoordinator.stageBatch({
+            state,
+            policy: activePolicy,
+            token: state.token,
+        });
+        if (result.kind === 'stale') {
+            return { kind: 'stale' };
+        }
+        if (result.kind === 'ready') {
+            const pending = this.deps.approvalFlow.getPending?.();
+            state.currentCallIds = this.#activeCallIdsForResponseCycle(state.currentState, pending?.interruption, state.currentCallIds, true);
+        }
+        return result;
+    }
+    async *#handleContinuationRecovery(error, state) {
+        const recoveryIterator = this.deps.continuationRecoveryHandler.handle({ error, state });
+        let recoveryNext = await recoveryIterator.next();
+        while (!recoveryNext.done) {
+            yield recoveryNext.value;
+            recoveryNext = await recoveryIterator.next();
+        }
+        return recoveryNext.value;
+    }
+    #buildResponse(result, usage) {
+        return {
+            type: 'response',
+            commandMessages: result.commandMessages ?? [],
+            finalText: result.finalText,
+            ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
+            ...(usage && Object.keys(usage).length > 0 ? { usage } : {}),
+            turnItems: result.turnItems,
+        };
+    }
+    async #handleApprovalOutcome(outcome, state, activePolicy, nextCumulativeUsage, previousInputForSurge) {
+        const { kind } = outcome;
+        if (kind === 'auto_approve') {
+            this.deps.logger.debug('Shell command auto-approved by LLM', {
+                eventType: 'approval.auto_approved',
+                category: 'approval',
+                phase: 'approval',
+                sessionId: this.deps.sessionId,
+                traceId: this.deps.logger.getCorrelationId(),
+                callId: outcome.callId,
+                command: outcome.argumentsText,
+                model: outcome.advisory?.model,
+                reasoning: outcome.advisory?.reasoning,
+            });
+            const nextPlan = this.deps.approvalFlow.prepareContinuation('y', undefined);
+            if (!nextPlan) {
+                const approvalFallback = this.#createApprovalRequiredFromAutoApprove(outcome, nextCumulativeUsage);
+                return { action: 'return', result: { kind: 'approval_required', terminal: approvalFallback } };
+            }
+            return { action: 'loop', nextPlan, isApproved: true };
+        }
+        const approvalContext = {
+            toolName: outcome.result.approval.toolName,
+            argumentsText: outcome.result.approval.argumentsText,
+            callId: outcome.result.approval.callId,
+            llmAdvisory: outcome.result.approval.llmAdvisory,
+        };
+        const decision = await activePolicy.decide(approvalContext);
+        if (decision === 'prompt') {
+            this.deps.planApplier.recordPendingApproval(approvalContext);
+            if (outcome.result.approval.callId) {
+                this.deps.logger.debug('Tool approval required', {
+                    eventType: 'approval.required',
+                    category: 'approval',
+                    phase: 'approval',
+                    sessionId: this.deps.sessionId,
+                    traceId: this.deps.logger.getCorrelationId(),
+                    toolName: outcome.result.approval.toolName,
+                });
+            }
+            this.#recordSuccess(state, previousInputForSurge);
+            const resultWithUsage = {
+                ...outcome.result,
+                ...(nextCumulativeUsage && Object.keys(nextCumulativeUsage).length > 0 ? { usage: nextCumulativeUsage } : {}),
+            };
+            return { action: 'return', result: { kind: 'approval_required', terminal: resultWithUsage } };
+        }
+        if (decision === 'approve') {
+            this.deps.logger.debug('Shell command auto-approved by policy', {
+                eventType: 'approval.auto_approved',
+                category: 'approval',
+                phase: 'approval',
+                sessionId: this.deps.sessionId,
+                traceId: this.deps.logger.getCorrelationId(),
+                callId: approvalContext.callId,
+                command: approvalContext.argumentsText,
+            });
+        }
+        const answer = decision === 'approve' ? 'y' : 'n';
+        const nextPlan = this.deps.approvalFlow.prepareContinuation(answer, undefined);
+        if (!nextPlan) {
+            return { action: 'return', result: { kind: 'approval_required', terminal: outcome.result } };
+        }
+        return { action: 'loop', nextPlan, isApproved: answer === 'y' };
+    }
+    async *#executeContinuationStreamCycle(state) {
+        const stream = (await this.deps.agentClient.continueRunStream(state.currentState, {
+            previousResponseId: state.currentResumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
+            sessionId: this.deps.sessionId,
+            toolResultCallIds: state.currentCallIds,
+        }));
+        state.setLastStream(stream);
+        const allEmittedIds = new Set([...state.previouslyEmittedIds]);
+        const acc = yield* this.deps.streamProcessor.process(stream, {
+            gen: state.token,
+            source: state.source,
+            preserveExistingToolArgs: true,
+            previouslyEmittedCommandIds: allEmittedIds,
+        });
+        const finalizeResult = this.deps.streamProcessor.finalize(stream, state.token, state.inputMode, state.source);
+        if (finalizeResult.kind === 'stale') {
+            return { kind: 'stale' };
+        }
+        const mergedEmittedIds = new Set([...allEmittedIds, ...acc.emittedCommandIds]);
+        const streamMessages = extractCommandMessages(stream.newItems || stream.history || []);
+        const filteredMessages = streamMessages.filter((msg) => !state.previouslyEmittedIds.has(msg.id));
+        const nextCumulativeMessages = [...state.cumulativeCommandMessages, ...filteredMessages];
+        const nextCumulativeUsage = acc.latestUsage ?? state.cumulativeUsage;
+        const nextCumulativeTurnItems = this.deps.turnAccumulator.getTurnItems();
+        const outcome = await buildConversationResult({
+            result: stream,
+            finalOutputOverride: acc.finalOutput || undefined,
+            reasoningOutputOverride: acc.reasoningOutput || undefined,
+            emittedCommandIds: mergedEmittedIds,
+            usage: acc.latestUsage,
+            toolCallArgumentsById: this.deps.toolTracker.argumentsById,
+            turnItems: nextCumulativeTurnItems,
+            token: state.token,
+            inputMode: state.inputMode,
+            cumulativeUsage: nextCumulativeUsage,
+            cumulativeCommandMessages: nextCumulativeMessages,
+            cumulativeTurnItems: nextCumulativeTurnItems,
+        }, {
+            approvalFlow: this.deps.approvalFlow,
+            shellAutoApproval: this.deps.shellAutoApproval,
+            logger: this.deps.logger,
+            sessionId: this.deps.sessionId,
+        });
+        return {
+            kind: 'completed',
+            outcome,
+            nextCumulativeMessages,
+            nextCumulativeUsage,
+            nextCumulativeTurnItems,
+            mergedEmittedIds,
+        };
+    }
+    #activeCallIdsForInit(init, prepared) {
+        if (init.kind === 'abort_resolution') {
+            return this.#activeCallIdsForAbortedContext(init.abortedContext);
+        }
+        return this.#activeCallIdsForResponseCycle(prepared.state, prepared.interruption, this.deps.toolTracker.activeCallIdsForCurrentTurn());
+    }
+    #activeCallIdsForResponseCycle(runState, primaryInterruption, fallbackCallIds, preserveFallback = false) {
+        const callIds = new Set();
+        const addCallId = (callId) => {
+            if (typeof callId === 'string' && callId.length > 0) {
+                callIds.add(callId);
+            }
+        };
+        if (preserveFallback) {
+            for (const callId of fallbackCallIds) {
+                addCallId(callId);
+            }
+        }
+        const interruptions = getMethod(runState, 'getInterruptions')?.();
+        if (Array.isArray(interruptions)) {
+            for (const interruption of interruptions) {
+                addCallId(getCallIdFromObject(interruption));
+            }
+        }
+        const consumedCallIds = new Set();
+        for (const item of this.deps.conversationStore.getHistory()) {
+            const record = asRecord(item);
+            const type = record?.type;
+            if (type !== 'function_call' && type !== 'tool_call') {
+                const callId = getCallIdFromObject(item);
+                if (callId) {
+                    consumedCallIds.add(callId);
+                }
+            }
+        }
+        const generatedItems = asRecord(runState)?._generatedItems;
+        if (Array.isArray(generatedItems)) {
+            for (const item of generatedItems) {
+                const raw = asRecord(item)?.rawItem;
+                const typeSource = asRecord(raw) ?? asRecord(item);
+                const type = typeof typeSource?.type === 'string' ? typeSource.type : '';
+                if (type === 'function_call_result' ||
+                    type === 'function_call_output' ||
+                    type === 'function_call_output_result' ||
+                    type === 'tool_call_output_item') {
+                    const callId = callIdOf(item);
+                    if (callId && !consumedCallIds.has(callId)) {
+                        addCallId(callId);
+                    }
+                }
+            }
+        }
+        addCallId(getCallIdFromObject(primaryInterruption));
+        if (callIds.size > 0) {
+            return [...callIds];
+        }
+        return [...fallbackCallIds];
+    }
+    #activeCallIdsForAbortedContext(abortedContext) {
+        const callIds = new Set();
+        const addCallId = (callId) => {
+            if (typeof callId === 'string' && callId.length > 0) {
+                callIds.add(callId);
+            }
+        };
+        const interruptions = getMethod(abortedContext.state, 'getInterruptions')?.();
+        if (Array.isArray(interruptions)) {
+            for (const interruption of interruptions) {
+                addCallId(getCallIdFromObject(interruption));
+            }
+        }
+        const generatedItems = asRecord(abortedContext.state)?._generatedItems;
+        if (Array.isArray(generatedItems)) {
+            for (const item of generatedItems) {
+                const raw = asRecord(item)?.rawItem;
+                const typeSource = asRecord(raw) ?? asRecord(item);
+                const type = typeof typeSource?.type === 'string' ? typeSource.type : '';
+                if (type === 'function_call_result' ||
+                    type === 'function_call_output' ||
+                    type === 'function_call_output_result' ||
+                    type === 'tool_call_output_item') {
+                    addCallId(callIdOf(item));
+                }
+            }
+        }
+        addCallId(getCallIdFromObject(abortedContext.interruption));
+        return [...callIds];
+    }
+    #recordSuccess(state, previousInputForSurge) {
+        this.deps.inputPlanner.recordSuccess(state.inputMode === 'delta' ? state.lastStream : this.deps.conversationStore.getHistory(), state.inputMode === 'delta'
+            ? { kind: state.inputMode }
+            : { kind: state.inputMode, previousInput: previousInputForSurge });
+    }
+    #createApprovalRequiredFromAutoApprove(outcome, usage) {
+        const pending = this.deps.approvalFlow.getPending();
+        if (pending) {
+            const { toolName, argumentsText } = getToolInfoFromInterruption(pending.interruption);
+            const agent = pending.interruption && typeof pending.interruption === 'object'
+                ? pending.interruption.agent
+                : undefined;
+            const agentName = agent && typeof agent === 'object' ? agent.name : 'Agent';
+            const callId = getCallIdFromObject(pending.interruption);
+            return createApprovalRequiredTerminal({
+                agentName: typeof agentName === 'string' ? agentName : 'Agent',
+                toolName: toolName ?? 'Unknown Tool',
+                argumentsText,
+                rawInterruption: pending.interruption,
+                callId: callId ? String(callId) : undefined,
+                llmAdvisory: outcome.advisory,
+                usage,
+            });
+        }
+        return createApprovalRequiredTerminal({
+            agentName: 'Agent',
+            toolName: 'Unknown Tool',
+            argumentsText: outcome.argumentsText,
+            rawInterruption: undefined,
+            callId: outcome.callId,
+            llmAdvisory: outcome.advisory,
+            usage,
+        });
+    }
+}
+//# sourceMappingURL=turn-workflow.js.map