@qduc/term2 0.27.0 → 0.28.0

package/dist/services/agent-runtime/application-run-loop.js

@@ -3,8 +3,7 @@ import { createContinuationHandle, unwrapContinuationHandle, } from '../../contr
 import { createAgentStream } from '../agent-stream.js';
 import { getRunCodeExecutionResult, runCodeExecutionMetadata } from '../../tools/system/run-code/run-code-execution.js';
 import { isZodToolParameterSchema } from '../../tools/types.js';
-import { normalizeToolParameters } from '../../lib/tool-invoke.js';
-import { isCancellationError, isHarnessInvariantError } from '../../lib/harness-invariant-error.js';
+import { describeError } from '../../utils/error-helpers.js';
 import { ApprovalLedger } from './tool-invocation-context.js';
 import { RunBudget, isRunBudgetInteraction, } from './run-budget.js';
 import { addTokenUsage, normalizeUsage } from '../../utils/ai/token-usage.js';
@@ -14,6 +13,8 @@ import { getCatalogPricingVersion, getModelPricing } from '../../services/cost/p
 import { DEFAULT_TOOL_ARGUMENT_RUNAWAY_SIGNATURE, GenerationGuard, GenerationGuardError, GenerationStreamDeadlines, ToolArgumentRunawayGuard, } from './generation-guard.js';
 import { classifyInLoopModelRetry, sleepWithAbort } from '../retry/in-loop-model-retry.js';
 import { buildFailureObservation } from '../decision-shadow/failure-observation.js';
+import { TurnInputMailbox } from './turn-input-mailbox.js';
+import { ToolCallExecution } from './tool-call-execution.js';
 /**
  * Tool results may carry provider-neutral content parts (for example the
  * image returned by read_file). Preserve only the known multimodal shape;
@@ -83,8 +84,6 @@ class EventQueue {
  * turns and silently drop later turns' records.
  */
 let nextCostRequestSeq = 0;
-let nextToolBatchSeq = 0;
-const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 3;
 /**
  * Small provider-neutral agent loop. It owns model-turn sequencing and tool
  * execution; providers only implement `StreamedModelTurn`.
@@ -92,33 +91,15 @@ const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 3;
 export class ApplicationRunLoop {
     #deps;
     #contextCompactionSessionState;
+    #turnInputMailbox;
     #activeAbortController = null;
-    #runInFlight = false;
     #segmentGeneration = 0;
-    /**
-     * Set when a segment ends holding approvals, meaning the turn is pausing
-     * rather than finishing. Injections offered during the pause wait here for
-     * the continuation segment instead of being refused for want of a run.
-     */
-    #turnPaused = false;
-    /**
-     * Set while a caller that owns turn boundaries has a turn open, from before
-     * its first request is built until after its last one settles.
-     *
-     * `#runInFlight` and `#turnPaused` only ever describe a *segment*, so between
-     * them they leave every gap in a turn where no run exists yet: the startup
-     * before the first request (provider model discovery, hooks, input
-     * preparation) and the backoff before a retry restarts the stream. A turn is
-     * steerable across those gaps, and only the caller that opened the turn knows
-     * they belong to it.
-     */
-    #turnOpen = false;
-    #pendingSteers = [];
     /** The run whose budget an out-of-band grant applies to, held across a pause. */
     #activeRunBudgetState;
     constructor(deps) {
         this.#deps = deps;
         this.#contextCompactionSessionState = deps.contextCompactionSessionState ?? { disabled: false };
+        this.#turnInputMailbox = new TurnInputMailbox((message, meta) => this.#deps.logDiagnostic?.(message, meta));
     }
     #observeTerminalFailure(error, request) {
         this.#observeDecisionShadow('failure_triage', () => {
@@ -147,25 +128,19 @@ export class ApplicationRunLoop {
      * be admitted now.
      */
     openTurn() {
-        this.#releasePendingSteers({ reason: 'superseded_by_new_turn' });
-        this.#turnOpen = true;
-        this.#turnPaused = false;
+        this.#turnInputMailbox.openTurn();
     }
     /**
      * Declare the turn over. Whatever is still waiting had no boundary left, so
      * it is handed back for the caller to send as its own turn.
      */
     closeTurn() {
-        this.#turnOpen = false;
-        this.#turnPaused = false;
-        this.#releasePendingSteers({ reason: 'turn_closed' });
+        this.#turnInputMailbox.closeTurn();
     }
     abort() {
         this.abortSegment();
         // An aborted turn will not resume, so nothing may keep waiting on it.
-        this.#turnOpen = false;
-        this.#turnPaused = false;
-        this.#releasePendingSteers({ reason: 'aborted' });
+        this.#turnInputMailbox.abortTurn();
     }
     /**
      * Stop the segment currently streaming without judging the turn's fate.
@@ -209,6 +184,15 @@ export class ApplicationRunLoop {
             return true;
         return state.runBudget.grantExtension('parent').granted;
     }
+    #createToolCallExecution() {
+        return new ToolCallExecution({
+            toolLifecycle: this.#deps.toolLifecycle,
+            getOnToolDispatch: this.#deps.getOnToolDispatch,
+            resolveMaxParallelToolCalls: this.#deps.resolveMaxParallelToolCalls,
+            isMaxTurnsExceeded: (error) => error instanceof MaxTurnsExceededError,
+            logDiagnostic: this.#deps.logDiagnostic,
+        });
+    }
     /**
      * Hand the running turn a user message to send with its next model request.
      *
@@ -234,32 +218,21 @@ export class ApplicationRunLoop {
      * only released or admitted.
      */
     steer(items, options) {
-        if (items.length === 0)
-            return Promise.resolve('released');
-        if (!this.#turnOpen && !this.#runInFlight && !this.#turnPaused)
-            return Promise.resolve('released');
-        return new Promise((resolve) => {
-            this.#pendingSteers.push({ id: options?.id, items, resolve });
-        });
+        return this.#turnInputMailbox.offer(items, options);
     }
     /**
      * Drop a still-waiting steer before it reaches a request boundary. Returns
      * `false` when the id is unknown, including when it was already admitted.
      *
-     * Invariant: this and `#admitPendingSteers` are both synchronous, and the
-     * latter drains `#pendingSteers` in a single pass — so the two can never
+     * Invariant: this and `TurnInputMailbox.admitAtRequestBoundary` are both synchronous,
+     * and the latter drains the mailbox in a single pass — so the two can never
      * interleave. A retraction is decided in the same tick against whatever is
-     * currently in `#pendingSteers`; once an item has been admitted it is no
+     * currently pending; once an item has been admitted it is no
      * longer in that array for this method to find. No locking is needed to
      * close the race between "the user retracts" and "the turn admits".
      */
     retractSteer(id) {
-        const index = this.#pendingSteers.findIndex((steer) => steer.id === id);
-        if (index < 0)
-            return false;
-        const [steer] = this.#pendingSteers.splice(index, 1);
-        steer.resolve('retracted');
-        return true;
+        return this.#turnInputMailbox.retract(id);
     }
     /**
      * Replace a waiting steer's items in place, keeping its position (and thus
@@ -268,21 +241,7 @@ export class ApplicationRunLoop {
      * same synchronicity invariant as `retractSteer`.
      */
     editSteer(id, items) {
-        const index = this.#pendingSteers.findIndex((steer) => steer.id === id);
-        if (index < 0)
-            return false;
-        this.#pendingSteers[index] = { ...this.#pendingSteers[index], items };
-        return true;
-    }
-    /** Settle every steer this run did not admit so callers stop waiting on it. */
-    #releasePendingSteers(reason = {}) {
-        const pending = this.#pendingSteers;
-        this.#pendingSteers = [];
-        if (pending.length > 0) {
-            this.#deps.logDiagnostic?.('Steer released at run end', { released: pending.length, ...reason });
-        }
-        for (const steer of pending)
-            steer.resolve('released');
+        return this.#turnInputMailbox.edit(id, items);
     }
     /**
      * Append waiting steers to the turn as ordinary user messages.
@@ -291,24 +250,6 @@ export class ApplicationRunLoop {
      * folded into a tool result — so the provider sees the user speaking after
      * the tool results of the round that was in flight when they typed.
      */
-    #admitPendingSteers(state, stream, queue) {
-        if (this.#pendingSteers.length === 0)
-            return;
-        const admitted = this.#pendingSteers;
-        this.#pendingSteers = [];
-        this.#deps.logDiagnostic?.('Steer admitted at request boundary', {
-            admitted: admitted.length,
-            turnCount: state.turnCount,
-        });
-        for (const steer of admitted) {
-            for (const item of steer.items) {
-                state.history.push(item);
-                state.input.push(...normalizeApplicationInput([item]));
-                outputPush(stream, queue, { type: 'item', item });
-            }
-            steer.resolve('admitted');
-        }
-    }
     startStream(agent, input, options = {}) {
         // Without a declared turn scope, a fresh stream is the only evidence this
         // loop gets that a new turn has begun: anything still waiting belonged to
@@ -316,14 +257,15 @@ export class ApplicationRunLoop {
         // With one, this call may equally be the same turn restarting after a
         // retry, which the loop cannot tell apart — so `openTurn`/`closeTurn` own
         // the decision instead.
-        this.#turnPaused = false;
-        if (!this.#turnOpen)
-            this.#releasePendingSteers({ reason: 'superseded_by_new_turn' });
+        this.#turnInputMailbox.startStream();
         const state = {
             agent,
+            toolExecution: this.#createToolCallExecution(),
             recoveryBudget: options.recoveryBudget,
             input: normalizeInput(input),
             history: normalizeHistory(input),
+            compactionHistory: options.compactionHistory,
+            usesDeltaHistory: Boolean(options.previousResponseId) && options.disableChainingForAttempt !== true,
             // A response ID is usable only after its provider origin is recorded.
             // This also makes old callers that omit providerId fail closed.
             responseId: options.disableChainingForAttempt !== true &&
@@ -331,7 +273,6 @@ export class ApplicationRunLoop {
                 options.supportsConversationChaining === true
                 ? options.previousResponseId ?? undefined
                 : undefined,
-            pendingApprovals: [],
             supportsConversationChaining: options.supportsConversationChaining === true,
             currentProviderId: options.providerId,
             responseProviderId: options.providerId && options.supportsConversationChaining === true && options.previousResponseId
@@ -393,11 +334,8 @@ export class ApplicationRunLoop {
             state.approvals = new ApprovalLedger();
         // A continuation handle from before approval batching carried only the
         // current pending item. Normalize it into the queue used by current runs.
-        if (!state.pendingApprovals)
-            state.pendingApprovals = state.pendingApproval ? [state.pendingApproval] : [];
-        if (!state.pendingApproval && state.pendingApprovals.length > 0) {
-            state.pendingApproval = state.pendingApprovals[0];
-        }
+        if (!state.toolExecution)
+            state.toolExecution = this.#createToolCallExecution();
         // Handles created before cost accounting existed have no record list.
         if (!state.costRecords)
             state.costRecords = [];
@@ -448,6 +386,8 @@ export class ApplicationRunLoop {
         // root closure for callers that do not provide one again.
         if (options.requestPreparation)
             state.requestPreparation = options.requestPreparation;
+        if (options.compactionHistory)
+            state.compactionHistory = options.compactionHistory;
         if (options.disableChainingForAttempt === true) {
             state.disableChainingForAttempt = true;
             state.responseId = undefined;
@@ -467,10 +407,8 @@ export class ApplicationRunLoop {
         this.abortSegment();
         const controller = new AbortController();
         this.#activeAbortController = controller;
-        this.#runInFlight = true;
+        this.#turnInputMailbox.startSegment();
         state.runBudget?.resume();
-        // This segment is running, so the turn is no longer paused between them.
-        this.#turnPaused = false;
         if (options.signal) {
             if (options.signal.aborted)
                 controller.abort();
@@ -531,42 +469,43 @@ export class ApplicationRunLoop {
                 return;
             if (this.#activeAbortController === controller)
                 this.#activeAbortController = null;
-            this.#runInFlight = false;
             // A segment that ends holding approvals has paused the turn, not ended
             // it: the caller resumes through continueRunStream, which offers
             // another request boundary. Injections wait for it. Only a segment
             // that ends with nothing outstanding has truly finished the turn, and
             // then anything still waiting has to be sent as its own turn instead.
-            const pendingApprovals = state.pendingApprovals?.length ?? 0;
+            const pendingApprovals = state.toolExecution.pendingApprovals.length;
             const pendingBudgetInteraction = state.pendingRunBudgetInteraction !== undefined;
             const cancelled = stream.cancelled === true;
-            this.#turnPaused = (pendingApprovals > 0 || pendingBudgetInteraction) && !cancelled && exitError === undefined;
-            if (this.#turnPaused)
+            const turnPaused = (pendingApprovals > 0 || pendingBudgetInteraction) && !cancelled && exitError === undefined;
+            this.#turnInputMailbox.settleSegment({
+                paused: turnPaused,
+                reason: {
+                    pendingApprovals,
+                    pendingBudgetInteraction,
+                    cancelled,
+                    error: exitError instanceof Error ? exitError.name : exitError ? String(exitError) : undefined,
+                    turnCount: state.turnCount,
+                },
+            });
+            if (turnPaused)
                 return;
             if (this.#activeRunBudgetState === state)
                 this.#activeRunBudgetState = undefined;
-            // A declared turn outlives its segments — this one may be about to be
-            // retried, or resumed past a post-execute gate. Its owner says when it
-            // is over.
-            if (this.#turnOpen)
-                return;
-            this.#releasePendingSteers({
-                pendingApprovals,
-                pendingBudgetInteraction,
-                cancelled,
-                error: exitError instanceof Error ? exitError.name : exitError ? String(exitError) : undefined,
-                turnCount: state.turnCount,
-            });
         });
         this.#activeRunBudgetState = state.runBudget ? state : undefined;
         return stream;
     }
     /** Route boundary advice through the same admission lane as mode notices. */
     #queuePendingSystemNotice(text) {
-        this.#pendingSteers.push({
-            items: [{ type: 'message', role: 'user', content: `[Mode Notice] ${text}` }],
-            resolve: () => undefined,
-        });
+        this.#turnInputMailbox.enqueueInternal({ type: 'message', role: 'user', content: `[Mode Notice] ${text}` });
+    }
+    #admitPendingSteers(state, stream, queue) {
+        this.#turnInputMailbox.admitAtRequestBoundary((item) => {
+            state.history.push(item);
+            state.input.push(...normalizeApplicationInput([item]));
+            outputPush(stream, queue, { type: 'item', item });
+        }, state.turnCount);
     }
     async #execute(state, stream, queue, options, toolContext, requestAbortController) {
         while (true) {
@@ -586,35 +525,14 @@ export class ApplicationRunLoop {
                     return this.#pauseForRunBudgetInteraction(state, stream, queue);
                 }
             }
-            state.pendingApprovals ??= state.pendingApproval ? [state.pendingApproval] : [];
-            if (state.pendingApprovals.length > 0 && state.approvalDecision) {
-                const selectedIndex = state.approvalDecisionCallId
-                    ? state.pendingApprovals.findIndex((pending) => getInterruptionCallId(pending.interruption) === state.approvalDecisionCallId)
-                    : -1;
-                if (state.approvalDecisionCallId && selectedIndex < 0) {
-                    throw new Error(`Approval decision references unknown pending tool call: ${state.approvalDecisionCallId}`);
-                }
-                const pendingIndex = selectedIndex >= 0 ? selectedIndex : 0;
-                const pending = state.pendingApprovals[pendingIndex];
-                const approved = state.approvalDecision === 'approved';
-                if (approved) {
-                    state.approvals.approveTool({ toolName: pending.toolName, callId: pending.callId });
-                }
-                else {
-                    state.approvals.rejectTool({ toolName: pending.toolName, callId: pending.callId }, { message: state.approvalMessage });
-                }
-                pending.plan.status = 'ready';
-                if (!approved)
-                    pending.plan.output = state.approvalMessage ?? 'rejected';
-                state.pendingApprovals.splice(pendingIndex, 1);
-                state.pendingApproval = state.pendingApprovals[0];
+            if (state.toolExecution.pendingApprovals.length > 0 && state.approvalDecision) {
+                state.toolExecution.resolveApproval(state.approvalDecisionCallId, state.approvalDecision, state.approvalMessage, state.approvals);
                 state.approvalDecision = undefined;
                 state.approvalDecisionCallId = undefined;
                 state.approvalMessage = undefined;
-                await this.#settleToolPlan(state, stream, queue, toolContext);
-                stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
-                if (state.pendingApprovals.length > 0) {
-                    this.#turnPaused = true;
+                await state.toolExecution.settle(this.#toolCallContext(state, stream, queue, toolContext));
+                stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
+                if (state.toolExecution.pendingApprovals.length > 0) {
                     return finish(stream, state, queue);
                 }
                 // Nothing is outstanding, so this segment is terminal — see
@@ -627,11 +545,10 @@ export class ApplicationRunLoop {
             // A budget interaction can park a response after its tool calls are
             // recorded but before any body runs. Resume those retained calls only
             // after processing an ordinary approval decision for that same plan.
-            if (state.toolPlan) {
-                await this.#settleToolPlan(state, stream, queue, toolContext);
-                if (state.pendingApprovals?.length) {
-                    stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
-                    this.#turnPaused = true;
+            if (state.toolExecution.hasPlan) {
+                await state.toolExecution.settle(this.#toolCallContext(state, stream, queue, toolContext));
+                if (state.toolExecution.pendingApprovals.length) {
+                    stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
                     return finish(stream, state, queue);
                 }
             }
@@ -643,25 +560,36 @@ export class ApplicationRunLoop {
                 this.#evaluateRunBudget(state, stream, queue);
                 if (state.pendingRunBudgetInteraction)
                     return this.#pauseForRunBudgetInteraction(state, stream, queue);
-                const boundaryDecision = options.onRequestBoundary?.(state.history, (text) => this.#queuePendingSystemNotice(text), {
+                const compactionHistoryResult = state.usesDeltaHistory
+                    ? state.compactionHistory
+                        ? mergeChainedCompactionHistory(state.compactionHistory, state.history)
+                        : { kind: 'skipped', reason: 'missing_snapshot' }
+                    : { kind: 'ready', history: state.history };
+                const boundaryDecision = options.onRequestBoundary?.(compactionHistoryResult.kind === 'ready' ? compactionHistoryResult.history : state.history, (text) => this.#queuePendingSystemNotice(text), {
                     ...(state.lastCompletedInputTokens !== undefined
                         ? { lastCompletedInputTokens: state.lastCompletedInputTokens }
                         : {}),
+                    ...(compactionHistoryResult.kind === 'skipped'
+                        ? { compactionSkipReason: compactionHistoryResult.reason }
+                        : {}),
                 });
-                if (options.boundaryCompaction && !boundaryDecision?.deferCompaction) {
+                const compactionHistory = compactionHistoryResult.kind === 'ready' ? compactionHistoryResult.history : undefined;
+                if (options.boundaryCompaction && compactionHistory && !boundaryDecision?.deferCompaction) {
                     const compactionStartedAt = Date.now();
                     const compaction = await options.boundaryCompaction.compact({
-                        history: state.history,
+                        history: compactionHistory,
                         automaticCompactionsThisRun: state.automaticCompactionsThisRun ?? 0,
                         lastCompletedInputTokens: state.lastCompletedInputTokens,
                         signal: options.signal,
                         onStarted: (provider) => outputPush(stream, queue, { type: 'context_compaction_started', provider, strategy: 'local' }),
                     });
                     if (compaction.kind === 'compacted') {
+                        state.compactedDuringRun = true;
                         state.history.splice(0, state.history.length, ...compaction.history);
                         state.input.splice(0, state.input.length, ...normalizeApplicationInput(compaction.modelInput));
                         state.responseId = undefined;
                         state.responseProviderId = undefined;
+                        state.usesDeltaHistory = false;
                         if (compaction.costRecords?.length) {
                             state.costRecords ??= [];
                             state.costRecords.push(...compaction.costRecords);
@@ -749,10 +677,19 @@ export class ApplicationRunLoop {
                     state.responseId = undefined;
                     state.responseProviderId = undefined;
                 }
+                // A per-request signal lets a recoverable guard trip cancel only this
+                // provider request; the segment signal still cancels everything.
+                const requestSignal = new AbortController();
+                const abortRequest = () => requestSignal.abort();
+                if (options.signal?.aborted)
+                    requestSignal.abort();
+                else
+                    options.signal?.addEventListener('abort', abortRequest, { once: true });
+                const requestInstructions = state.agent.resolveInstructionsForRequest?.() ?? state.agent.instructions;
                 const request = {
                     instructions: criticalWrapUp
-                        ? `${state.agent.instructions}\n\nBudget containment is terminal. Do not call tools. In this one final response, summarize what you completed, the evidence you have, and what remains.`
-                        : state.agent.instructions,
+                        ? `${requestInstructions}\n\nBudget containment is terminal. Do not call tools. In this one final response, summarize what you completed, the evidence you have, and what remains.`
+                        : requestInstructions,
                     ...(state.supportsConversationChaining &&
                         !disableChaining &&
                         state.responseId &&
@@ -780,7 +717,7 @@ export class ApplicationRunLoop {
                                 : state.agent.modelSettings.providerData,
                         }
                         : {}),
-                    ...(options.signal ? { signal: options.signal } : {}),
+                    signal: requestSignal.signal,
                     ...(state.recoveryBudget ? { recoveryBudget: state.recoveryBudget } : {}),
                 };
                 activeRequest = request;
@@ -884,7 +821,12 @@ export class ApplicationRunLoop {
                     break;
                 }
                 catch (error) {
-                    if (error instanceof GenerationGuardError)
+                    const recoverOversizedToolArgument = isOversizedToolArgumentTrip(error) &&
+                        (state.oversizedToolArgumentRecoveries ?? 0) < MAX_OVERSIZED_TOOL_ARGUMENT_RECOVERIES &&
+                        !options.signal?.aborted;
+                    if (recoverOversizedToolArgument)
+                        requestSignal.abort();
+                    else if (error instanceof GenerationGuardError)
                         requestAbortController.abort();
                     const decision = classifyInLoopModelRetry(error, attempt, maxRetries, Math.random, {
                         previousResponseId: activeRequest?.previousResponseId,
@@ -904,6 +846,23 @@ export class ApplicationRunLoop {
                             });
                         }
                     };
+                    if (recoverOversizedToolArgument) {
+                        // No tool ran: a call is dispatched only after its arguments
+                        // complete. Discard the partial response and ask for smaller calls.
+                        state.oversizedToolArgumentRecoveries = (state.oversizedToolArgumentRecoveries ?? 0) + 1;
+                        state.input.splice(inputLengthBefore);
+                        state.history.splice(historyLengthBefore);
+                        state.criticalWrapUpDispatched = criticalWrapUpDispatchedBefore;
+                        rollbackProvisionalAttempt();
+                        this.#deps.logDiagnostic?.('Recovering oversized tool argument in run loop', {
+                            code: error.code,
+                            recovery: state.oversizedToolArgumentRecoveries,
+                            maxRecoveries: MAX_OVERSIZED_TOOL_ARGUMENT_RECOVERIES,
+                        });
+                        this.#queuePendingSystemNotice(oversizedToolArgumentNotice(error.message));
+                        this.#admitPendingSteers(state, stream, queue);
+                        continue;
+                    }
                     if (decision.retryable && !options.signal?.aborted) {
                         attempt++;
                         state.input.splice(inputLengthBefore);
@@ -920,7 +879,7 @@ export class ApplicationRunLoop {
                             maxRetries,
                             kind: decision.kind,
                             delayMs: decision.delayMs,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: describeError(error),
                         });
                         await (this.#deps.waitBeforeModelRetry ?? sleepWithAbort)(decision.delayMs, options.signal);
                         continue;
@@ -955,6 +914,9 @@ export class ApplicationRunLoop {
                     });
                     throw error;
                 }
+                finally {
+                    options.signal?.removeEventListener('abort', abortRequest);
+                }
             }
             if (!completion) {
                 // A few application-owned model fixtures (and legacy adapters) end a
@@ -976,11 +938,10 @@ export class ApplicationRunLoop {
                     return finish(stream, state, queue);
                 }
                 await this.#dispatchToolCalls(state, stream, queue, streamedToolCalls, toolContext);
-                if (state.terminateAfterToolExecution)
+                if (state.toolExecution.terminateAfterExecution)
                     return finish(stream, state, queue);
-                if (state.pendingApprovals && state.pendingApprovals.length > 0) {
-                    stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
-                    this.#turnPaused = true;
+                if (state.toolExecution.pendingApprovals.length > 0) {
+                    stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
                     return finish(stream, state, queue);
                 }
                 continue;
@@ -1105,7 +1066,10 @@ export class ApplicationRunLoop {
                     continue;
                 const historyItem = {
                     ...item.item,
-                    providerOpaque: { provider: item.provider },
+                    providerOpaque: {
+                        provider: item.provider,
+                        ...(item.sourceProvider ? { sourceProvider: item.sourceProvider } : {}),
+                    },
                 };
                 state.history.push(historyItem);
                 state.input.push(item);
@@ -1142,7 +1106,7 @@ export class ApplicationRunLoop {
             if (!state.criticalWrapUpPending && toolCalls.length > 0) {
                 await this.#dispatchToolCalls(state, stream, queue, toolCalls, toolContext);
             }
-            if (state.terminateAfterToolExecution)
+            if (state.toolExecution.terminateAfterExecution)
                 return finish(stream, state, queue);
             // A critical subagent gets exactly this final tool-free model call.
             if (criticalWrapUp)
@@ -1150,9 +1114,8 @@ export class ApplicationRunLoop {
             if (state.pendingRunBudgetInteraction && toolCalls.length > 0) {
                 return this.#pauseForRunBudgetInteraction(state, stream, queue);
             }
-            if (state.pendingApprovals.length > 0) {
-                stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
-                this.#turnPaused = true;
+            if (state.toolExecution.pendingApprovals.length > 0) {
+                stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
                 return finish(stream, state, queue);
             }
             if (!sawToolCall) {
@@ -1164,178 +1127,51 @@ export class ApplicationRunLoop {
         }
     }
     async #dispatchToolCalls(state, stream, queue, events, toolContext) {
-        const plan = events.map((event) => {
-            const definition = state.agent.tools.find((tool) => tool.name === event.name);
-            const callItem = {
-                type: event.toolType === 'custom' ? 'custom_tool_call' : 'function_call',
-                callId: event.id,
-                name: event.name,
-                ...(event.toolType === 'custom' ? { input: event.arguments } : { arguments: event.arguments }),
-            };
-            state.history.push(callItem);
-            state.input.push({
-                type: 'tool_call',
-                id: event.id,
-                name: event.name,
-                arguments: event.arguments,
-                ...(event.toolType ? { toolType: event.toolType } : {}),
-            });
-            outputPush(stream, queue, { type: 'item', item: callItem });
-            return {
-                event,
-                definition,
-                parallelSafe: false,
-                status: 'ready',
-            };
-        });
-        state.toolPlan = plan;
-        for (const entry of plan) {
-            const { event, definition } = entry;
-            if (!definition) {
-                entry.output = `Unknown tool: ${event.name}`;
-                continue;
-            }
-            // Keep the raw-model invocation contract: normalization repairs the
-            // accepted object shape but intentionally does not Zod-parse it, which
-            // would apply schema defaults before execute. web_fetch relies on its
-            // executor fallbacks on the strict JSON-schema path.
-            try {
-                const parsedArguments = definition.parseModelArguments
-                    ? definition.parseModelArguments(event.arguments)
-                    : parseArguments(event.arguments);
-                entry.params = normalizeToolParameters(parsedArguments, definition.parameters);
-            }
-            catch (error) {
-                entry.output = `Error: Invalid patch: ${error instanceof Error ? error.message : String(error)}`;
-                continue;
-            }
-            const stallEvent = state.runBudget?.observeToolCall({
-                name: event.name,
-                argumentsText: event.arguments,
-                effect: definition.effect,
-            });
-            if (stallEvent) {
-                this.#emitRunBudgetEvent(state, stallEvent, 'Tool stall evidence', stream, queue);
-            }
-            // Consult this run's ledger before prompting: a decision already taken
-            // (in the parent run and replayed in, or earlier in this run) must not
-            // prompt again. This is what makes approval replay observable.
-            const alreadyDecided = state.approvals.isToolApproved({ toolName: event.name, callId: event.id });
-            if (alreadyDecided === false) {
-                entry.output = state.approvals.getRejectionMessage(event.name, event.id) ?? 'Tool execution was not approved.';
-                continue;
-            }
-            if (alreadyDecided !== true && (await definition.needsApproval(entry.params, toolContext))) {
-                entry.status = 'approval_pending';
-                const pending = {
+        const context = this.#toolCallContext(state, stream, queue, toolContext);
+        await state.toolExecution.plan(events, context);
+        stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
+        if (!state.pendingRunBudgetInteraction)
+            await state.toolExecution.settle(context);
+    }
+    #toolCallContext(state, stream, queue, toolContext) {
+        return {
+            tools: state.agent.tools,
+            approvals: state.approvals,
+            toolContext,
+            sessionId: state.sessionId,
+            turnId: state.turnId,
+            hookScope: state.hookScope,
+            onCall: (event) => {
+                const callItem = {
+                    type: event.toolType === 'custom' ? 'custom_tool_call' : 'function_call',
                     callId: event.id,
-                    toolName: event.name,
-                    argumentsText: event.arguments,
-                    interruption: {
-                        type: 'tool_approval_item',
-                        rawItem: { type: 'function_call', callId: event.id, name: event.name, arguments: event.arguments },
-                        callId: event.id,
-                        name: event.name,
-                        arguments: event.arguments,
-                    },
-                    definition,
-                    params: entry.params,
-                    plan: entry,
+                    name: event.name,
+                    ...(event.toolType === 'custom' ? { input: event.arguments } : { arguments: event.arguments }),
                 };
-                state.pendingApprovals ??= [];
-                state.pendingApprovals.push(pending);
-                continue;
-            }
-            entry.parallelSafe = await isParallelSafe(definition, entry.params, toolContext);
-        }
-        state.pendingApproval = state.pendingApprovals?.[0];
-        stream.interruptions = (state.pendingApprovals ?? []).map((item) => item.interruption);
-        this.#deps.logDiagnostic?.('tool parallel eligibility', {
-            decisions: plan.map((entry) => ({
-                callId: entry.event.id,
-                toolName: entry.event.name,
-                parallelSafe: entry.parallelSafe,
-                approvalPending: entry.status === 'approval_pending',
-            })),
-        }, { severity: 'debug', eventType: 'tool.parallel.eligibility' });
-        // A main-agent budget escalation is a real boundary: retain the planned
-        // calls, but do not execute one more tool while human judgement is pending.
-        if (!state.pendingRunBudgetInteraction) {
-            await this.#settleToolPlan(state, stream, queue, toolContext);
-        }
-    }
-    async #settleToolPlan(state, stream, queue, toolContext) {
-        const plan = state.toolPlan;
-        if (!plan)
-            return;
-        const maxParallelToolCalls = Math.max(1, Math.floor(this.#deps.resolveMaxParallelToolCalls?.() ?? DEFAULT_MAX_PARALLEL_TOOL_CALLS));
-        while (true) {
-            const firstPending = plan.find((entry) => entry.status !== 'completed');
-            if (!firstPending) {
-                state.toolPlan = undefined;
-                return;
-            }
-            if (firstPending.status === 'approval_pending')
-                return;
-            const group = [];
-            for (const entry of plan) {
-                if (entry.status === 'completed')
-                    continue;
-                if (entry.status === 'approval_pending')
-                    break;
-                if (group.length > 0 && (!entry.parallelSafe || !group[0].parallelSafe || group.length >= maxParallelToolCalls))
-                    break;
-                group.push(entry);
-                if (!entry.parallelSafe)
-                    break;
-            }
-            const batchId = `tool-batch-${++nextToolBatchSeq}`;
-            this.#deps.logDiagnostic?.('tool batch dispatched', {
-                batchId,
-                callIds: group.map((entry) => entry.event.id),
-                parallel: group.length > 1,
-                maxParallelToolCalls,
-                dispatchOrder: group.map((entry) => entry.event.id),
-            }, { severity: 'debug', eventType: 'tool.batch.dispatched' });
-            for (const entry of group) {
+                state.history.push(callItem);
+                state.input.push({
+                    type: 'tool_call',
+                    id: event.id,
+                    name: event.name,
+                    arguments: event.arguments,
+                    ...(event.toolType ? { toolType: event.toolType } : {}),
+                });
+                outputPush(stream, queue, { type: 'item', item: callItem });
+            },
+            onDispatch: (entry) => {
                 outputPush(stream, queue, {
                     type: 'tool_call_dispatched',
                     callId: entry.event.id,
                     toolName: entry.event.name,
                 });
-            }
-            if (group.length > 1) {
-                const results = await Promise.allSettled(group.map((entry) => this.#invokePlannedTool(entry, toolContext, state)));
-                const rejected = results.find((result) => result.status === 'rejected');
-                if (rejected)
-                    throw rejected.reason;
-                for (const [index, result] of results.entries()) {
-                    const value = result.value;
-                    group[index].result = value;
-                    this.#appendToolResult(state, stream, queue, group[index], value);
-                }
-            }
-            else {
-                const result = await this.#invokePlannedTool(group[0], toolContext, state);
-                group[0].result = result;
-                this.#appendToolResult(state, stream, queue, group[0], result);
-            }
-            this.#deps.logDiagnostic?.('tool batch settled', {
-                batchId,
-                settlementOrder: group.map((entry) => entry.event.id),
-            }, { severity: 'debug', eventType: 'tool.batch.settled' });
-            if (group.some((entry) => shouldTerminateAfterExecution(entry.definition, entry.result))) {
-                state.terminateAfterToolExecution = true;
-                state.toolPlan = undefined;
-                return;
-            }
-        }
-    }
-    async #invokePlannedTool(entry, toolContext, state) {
-        entry.status = 'completed';
-        if (entry.output !== undefined)
-            return entry.output;
-        return this.#invokeTool(entry.definition, entry.params, toolContext, entry.event.id, state);
+            },
+            onToolStall: (input) => {
+                const stallEvent = state.runBudget?.observeToolCall(input);
+                if (stallEvent)
+                    this.#emitRunBudgetEvent(state, stallEvent, 'Tool stall evidence', stream, queue);
+            },
+            onResult: (entry, result) => this.#appendToolResult(state, stream, queue, entry, result),
+        };
     }
     #appendToolResult(state, stream, queue, entry, result) {
         const runCodeExecution = getRunCodeExecutionResult(result);
@@ -1363,57 +1199,6 @@ export class ApplicationRunLoop {
         outputPush(stream, queue, { type: 'item', item: resultItem });
         this.#evaluateRunBudget(state, stream, queue);
     }
-    /**
-     * A tool that throws must not take the run down with it.
-     *
-     * Most tools already report failure by returning `Error: ...` as their
-     * output, which the model reads and acts on. The handful that throw got the
-     * opposite treatment for no principled reason: the exception escaped to
-     * `#execute`, closed the event queue, and ended the turn — so the model never
-     * saw a recoverable problem like a path that does not exist, and the caller
-     * lost the whole turn. Worse, `#handleToolCall` pushes the `function_call`
-     * into history before executing, so an escape leaves a call with no matching
-     * result.
-     *
-     * Errors are therefore normalized into tool output, with two exceptions that
-     * must still propagate: cancellation (the run is ending on purpose) and
-     * `HarnessInvariantError` (a bug here, which the model cannot act on).
-     */
-    async #invokeTool(definition, params, toolContext, callId, state) {
-        const startedAt = Date.now();
-        const attempt = state
-            ? ((state.toolAttempts ??= new Map()).set(callId, (state.toolAttempts.get(callId) ?? 0) + 1),
-                state.toolAttempts.get(callId))
-            : 1;
-        const lifecycleContext = {
-            ...(state?.sessionId ? { sessionId: state.sessionId } : {}),
-            ...(state?.turnId ? { turnId: state.turnId } : {}),
-            toolCallId: callId,
-            toolName: definition.name,
-            normalizedArguments: params,
-            attempt,
-            scope: state?.hookScope ?? 'root',
-        };
-        // Dispatch mark must run before execute so a mid-tool stream failure can
-        // settle the ledger as unknown rather than aborted.
-        this.#deps.getOnToolDispatch?.()?.(callId);
-        await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.before(lifecycleContext));
-        try {
-            const result = await definition.execute(params, toolContext, { toolCall: { callId } });
-            await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.after(lifecycleContext, result, Date.now() - startedAt));
-            return result;
-        }
-        catch (error) {
-            if (isCancellationError(error) || isHarnessInvariantError(error) || error instanceof MaxTurnsExceededError) {
-                await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, false));
-                throw error;
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            const result = `Error: ${message}`;
-            await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, true));
-            return result;
-        }
-    }
     #nextRequestId() {
         nextCostRequestSeq += 1;
         return `req-${nextCostRequestSeq}`;
@@ -1477,33 +1262,8 @@ export class ApplicationRunLoop {
         if (!interaction)
             return finish(stream, state, queue);
         stream.interruptions = [interaction];
-        this.#turnPaused = true;
         return finish(stream, state, queue);
     }
-    async #notifyToolLifecycle(operation) {
-        if (!operation)
-            return;
-        try {
-            await operation();
-        }
-        catch {
-            // Lifecycle observers are passive. A broken observer must not alter tool
-            // execution or turn recovery semantics.
-        }
-    }
-}
-function shouldTerminateAfterExecution(definition, result) {
-    const policy = definition?.terminateAfterExecution;
-    if (typeof policy === 'boolean')
-        return policy;
-    if (!policy)
-        return false;
-    try {
-        return policy(result);
-    }
-    catch {
-        return false;
-    }
 }
 function isLunaChainedRequest(state, request) {
     return (state.currentProviderId === 'codex' &&
@@ -1513,6 +1273,12 @@ function isLunaChainedRequest(state, request) {
         request.input.length === 1 &&
         request.input[0]?.type === 'tool_result');
 }
+function getInterruptionCallId(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const callId = value.callId;
+    return typeof callId === 'string' ? callId : undefined;
+}
 function outputPush(stream, queue, item) {
     stream.output.push(item);
     if (stream.newItems !== stream.output)
@@ -1521,6 +1287,7 @@ function outputPush(stream, queue, item) {
 }
 function finish(stream, state, queue) {
     stream.history = state.history;
+    stream.historyReplacedByCompaction = state.compactedDuringRun === true;
     stream.terminalCause = state.terminalCause;
     stream.latestProviderInputTokens = state.lastCompletedInputTokens;
     if (state.supportsConversationChaining &&
@@ -1623,31 +1390,6 @@ function normalizeModelUsage(usage) {
         reasoningTokens: rawUsage.outputTokens?.reasoning ?? rawUsage.reasoningTokens,
     });
 }
-function parseArguments(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return {};
-    }
-}
-async function isParallelSafe(definition, params, context) {
-    if (typeof definition.parallelSafe === 'function') {
-        try {
-            return await definition.parallelSafe(params, context);
-        }
-        catch {
-            return false;
-        }
-    }
-    return definition.parallelSafe === true;
-}
-function getInterruptionCallId(value) {
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const callId = value.callId;
-    return typeof callId === 'string' ? callId : undefined;
-}
 function toModelTools(tools) {
     return tools.map((tool) => tool.modelTool
         ? {
@@ -1685,6 +1427,37 @@ function normalizeHistory(input) {
         return [{ type: 'message', role: 'user', content: input }];
     return Array.isArray(input) ? [...input] : [input];
 }
+function mergeChainedCompactionHistory(sessionHistory, deltaHistory) {
+    const firstDeltaItem = deltaHistory[0];
+    if (!firstDeltaItem || firstDeltaItem.type !== 'message' || firstDeltaItem.role !== 'user') {
+        return { kind: 'skipped', reason: 'user_mismatch' };
+    }
+    let latestUserIndex = -1;
+    for (let index = sessionHistory.length - 1; index >= 0; index--) {
+        const item = sessionHistory[index];
+        if (item.type === 'message' && item.role === 'user') {
+            latestUserIndex = index;
+            break;
+        }
+    }
+    if (latestUserIndex < 0)
+        return { kind: 'skipped', reason: 'user_mismatch' };
+    const latestSessionUser = sessionHistory[latestUserIndex];
+    const normalizedDeltaUser = normalizeApplicationInput([firstDeltaItem]);
+    const normalizedSessionUser = normalizeApplicationInput([latestSessionUser]);
+    if (JSON.stringify(normalizedDeltaUser) !== JSON.stringify(normalizedSessionUser)) {
+        return { kind: 'skipped', reason: 'user_mismatch' };
+    }
+    return {
+        kind: 'ready',
+        history: [
+            ...sessionHistory.slice(0, latestUserIndex),
+            firstDeltaItem,
+            ...sessionHistory.slice(latestUserIndex + 1),
+            ...deltaHistory.slice(1),
+        ],
+    };
+}
 function asRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
 }
@@ -1814,7 +1587,14 @@ function isProviderOpaque(item) {
 function normalizeInputItem(item) {
     if (isProviderOpaque(item)) {
         const { providerOpaque: _marker, ...providerItem } = item;
-        return [{ type: 'provider_opaque', provider: item.providerOpaque.provider, item: providerItem }];
+        return [
+            {
+                type: 'provider_opaque',
+                provider: item.providerOpaque.provider,
+                ...(item.providerOpaque.sourceProvider ? { sourceProvider: item.providerOpaque.sourceProvider } : {}),
+                item: providerItem,
+            },
+        ];
     }
     if (item.type === 'function_call' || item.type === 'custom_tool_call') {
         return [
@@ -1866,4 +1646,19 @@ function normalizeInputItem(item) {
     }
     return [{ type: 'message', role, content }];
 }
+/**
+ * A legitimate but oversized tool call (usually one large edit) trips the
+ * tool-argument caps. Unlike runaway output it is answerable: tell the model
+ * the call never ran and let it split the work, a bounded number of times.
+ */
+const MAX_OVERSIZED_TOOL_ARGUMENT_RECOVERIES = 2;
+function isOversizedToolArgumentTrip(error) {
+    return (error instanceof GenerationGuardError &&
+        (error.code === 'tool_argument_characters' || error.code === 'cumulative_tool_argument_characters'));
+}
+function oversizedToolArgumentNotice(guardMessage) {
+    return (`Your previous response was discarded and its tool call was not executed. ${guardMessage} ` +
+        'Redo the work in smaller tool calls, each well under that limit — for example, several targeted ' +
+        'patches instead of rewriting a whole file in one call.');
+}
 //# sourceMappingURL=application-run-loop.js.map