@qduc/term2 0.12.0 → 0.14.0

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

@@ -55,6 +55,18 @@ class EventQueue {
         return new Promise((resolve, reject) => this.#waiters.push({ resolve, reject }));
     }
 }
+/**
+ * Process-wide monotonic counter for model-request cost ids.
+ *
+ * Request ids must be unique across every run in the process: root runs,
+ * subagent runs, and approval continuations all feed the same session
+ * accumulator, which dedups by id to make event + terminal double-delivery
+ * safe. A run-local sequence (as in a per-run counter) would collide across
+ * turns and silently drop later turns' records.
+ */
+let nextCostRequestSeq = 0;
+let nextToolBatchSeq = 0;
+const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 4;
 /**
  * Small provider-neutral agent loop. It owns model-turn sequencing and tool
  * execution; providers only implement `StreamedModelTurn`.
@@ -62,8 +74,10 @@ class EventQueue {
 export class ApplicationRunLoop {
     #deps;
     #contextCompactionSessionState;
+    #maxParallelToolCalls;
     #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
@@ -86,6 +100,7 @@ export class ApplicationRunLoop {
     constructor(deps) {
         this.#deps = deps;
         this.#contextCompactionSessionState = deps.contextCompactionSessionState ?? { disabled: false };
+        this.#maxParallelToolCalls = Math.max(1, Math.floor(deps.maxParallelToolCalls ?? DEFAULT_MAX_PARALLEL_TOOL_CALLS));
     }
     /**
      * Declare a turn open, making it steerable before its first run exists.
@@ -257,6 +272,7 @@ export class ApplicationRunLoop {
             approvals: options.approvals ?? new ApprovalLedger(),
             turnCount: 0,
             maxTurns: options.maxTurns,
+            automaticCompactionsThisRun: 0,
         };
         state.approve = (interruption) => {
             state.approvalDecision = 'approved';
@@ -336,6 +352,7 @@ export class ApplicationRunLoop {
     }
     #run(state, options) {
         const queue = new EventQueue();
+        const segmentGeneration = ++this.#segmentGeneration;
         this.abortSegment();
         const controller = new AbortController();
         this.#activeAbortController = controller;
@@ -387,6 +404,8 @@ export class ApplicationRunLoop {
             throw error;
         })
             .finally(() => {
+            if (segmentGeneration !== this.#segmentGeneration)
+                return;
             if (this.#activeAbortController === controller)
                 this.#activeAbortController = null;
             this.#runInFlight = false;
@@ -435,27 +454,20 @@ export class ApplicationRunLoop {
                 else {
                     state.approvals.rejectTool({ toolName: pending.toolName, callId: pending.callId }, { message: state.approvalMessage });
                 }
-                const rawResult = approved
-                    ? await this.#invokeTool(pending.definition, pending.params, toolContext, pending.callId, state)
-                    : state.approvalMessage ?? 'rejected';
-                const result = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult);
-                const resultItem = {
-                    type: 'function_call_result',
-                    callId: pending.callId,
-                    name: pending.toolName,
-                    output: result,
-                };
-                state.history.push(resultItem);
-                state.input.push({ type: 'tool_result', id: pending.callId, output: result });
-                outputPush(stream, queue, { type: 'item', item: resultItem });
+                pending.plan.status = 'ready';
+                if (!approved)
+                    pending.plan.output = state.approvalMessage ?? 'rejected';
                 state.pendingApprovals.splice(pendingIndex, 1);
                 state.pendingApproval = state.pendingApprovals[0];
                 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)
+                if (state.pendingApprovals.length > 0) {
+                    this.#turnPaused = true;
                     return finish(stream, state, queue);
+                }
                 // Nothing is outstanding, so this segment is terminal — see
                 // `stopAfterApprovalResolution`. Stopping here rather than at the
                 // request boundary below is what keeps the just-recorded tool result
@@ -467,17 +479,57 @@ export class ApplicationRunLoop {
             // history, and the next request has not been built. A user message
             // admitted here reaches the model in sequence, mid-turn.
             this.#admitPendingSteers(state, stream, queue);
+            if (options.boundaryCompaction) {
+                const compactionStartedAt = Date.now();
+                const compaction = await options.boundaryCompaction.compact({
+                    history: state.history,
+                    automaticCompactionsThisRun: state.automaticCompactionsThisRun ?? 0,
+                    signal: options.signal,
+                    onStarted: (provider) => outputPush(stream, queue, { type: 'context_compaction_started', provider, strategy: 'local' }),
+                });
+                if (compaction.kind === 'compacted') {
+                    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;
+                    if (compaction.costRecords?.length) {
+                        state.costRecords ??= [];
+                        state.costRecords.push(...compaction.costRecords);
+                    }
+                    state.automaticCompactionsThisRun = (state.automaticCompactionsThisRun ?? 0) + 1;
+                    outputPush(stream, queue, {
+                        type: 'context_compaction_completed',
+                        provider: state.currentProviderId ?? 'unknown',
+                        strategy: 'local',
+                        durationMs: Math.max(0, Date.now() - compactionStartedAt),
+                    });
+                }
+                else if (compaction.kind === 'failed') {
+                    outputPush(stream, queue, {
+                        type: 'context_compaction_failed',
+                        provider: compaction.provider,
+                        strategy: 'local',
+                        durationMs: Math.max(0, Date.now() - compactionStartedAt),
+                    });
+                }
+                // Summarization is an asynchronous part of this same request
+                // boundary. Admit anything that arrived while it was in flight after
+                // applying a replacement, so the steer cannot be overwritten by the
+                // checkpoint or miss a terminal model request.
+                this.#admitPendingSteers(state, stream, queue);
+            }
             state.turnCount += 1;
             if (state.maxTurns !== undefined && state.turnCount > state.maxTurns) {
                 throw new MaxTurnsExceededError(state.maxTurns);
             }
             const model = await this.#deps.resolveModel(state.agent.model);
             let sawToolCall = false;
+            const streamedToolCalls = [];
             let completion;
             let pendingNativeReasoning;
-            // Stable run-local request id, allocated immediately before dispatch so a
-            // cost record can be settled exactly once (success or failure).
-            const requestId = this.#nextRequestId(state);
+            // Stable process-unique request id, allocated immediately before dispatch
+            // so a cost record can be settled exactly once (success or failure).
+            const requestId = this.#nextRequestId();
             const request = {
                 instructions: state.agent.instructions,
                 ...(state.supportsConversationChaining &&
@@ -517,7 +569,7 @@ export class ApplicationRunLoop {
                 ...options.generationGuard,
             });
             const consume = async () => {
-                const deadline = new GenerationDeadline(generationGuard.requestDeadlineMs, () => requestAbortController.abort());
+                const deadline = new GenerationDeadline(generationGuard.requestDeadlineMs, () => requestAbortController.abort(), () => generationGuard.progress);
                 let iterator;
                 let iteratorFinished = false;
                 try {
@@ -562,7 +614,7 @@ export class ApplicationRunLoop {
                             generationGuard.observeToolCall(event.arguments);
                             pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
                             sawToolCall = true;
-                            await this.#handleToolCall(state, stream, queue, event, toolContext);
+                            streamedToolCalls.push(event);
                         }
                     }
                 }
@@ -589,17 +641,35 @@ export class ApplicationRunLoop {
                 // unpriced marker so the summary stays honest (partial) rather than
                 // appearing exact. Observational only: the error still propagates.
                 const cancelled = error instanceof Error && error.name === 'AbortError';
-                this.#appendCostRecord(state, {
+                const record = this.#appendCostRecord(state, {
                     requestId,
                     provider: state.currentProviderId,
                     model: state.agent.model,
                     tier: resolveServiceTier(request),
                     outcome: cancelled ? 'cancelled' : 'failed',
                 });
+                // Only the live queue sees cost records: `output`/`newItems` feed
+                // persistence and replay, and a cost event must never become a
+                // restored history item.
+                queue.push({ type: 'cost_update', record });
                 throw error;
             }
-            if (!completion)
-                throw new Error('Application model turn ended without completion');
+            if (!completion) {
+                // A few application-owned model fixtures (and legacy adapters) end a
+                // tool-call stream immediately after the call and use the next request
+                // as the continuation boundary. Preserve that contract while routing
+                // the calls through the same ordered dispatcher. An empty stream still
+                // fails closed as an incomplete model turn.
+                if (streamedToolCalls.length === 0)
+                    throw new Error('Application model turn ended without completion');
+                await this.#dispatchToolCalls(state, stream, queue, streamedToolCalls, toolContext);
+                if (state.pendingApprovals && state.pendingApprovals.length > 0) {
+                    stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+                    this.#turnPaused = true;
+                    return finish(stream, state, queue);
+                }
+                continue;
+            }
             // Commit the authoritative terminal state before handling terminal-only
             // tool calls. Approval may pause immediately after this point, and the
             // continuation must still carry the response that produced the calls.
@@ -645,7 +715,13 @@ export class ApplicationRunLoop {
                 normalizedCompletionUsage = undefined;
             }
             // Attribute cost while the dispatched request's identity is still known.
-            this.#appendCostRecord(state, {
+            // Emit it immediately so the UI can show this request's cost before the
+            // run ends; the terminal result re-delivers the cumulative record list
+            // and the session accumulator ignores the duplicates by request id.
+            // Only the live queue sees the event: `output`/`newItems` feed
+            // persistence and replay, and a cost event must never become a restored
+            // history item.
+            const record = this.#appendCostRecord(state, {
                 requestId,
                 provider: state.currentProviderId,
                 model: state.agent.model,
@@ -654,11 +730,13 @@ export class ApplicationRunLoop {
                 usage: normalizedCompletionUsage,
                 providerUsd: completion.costUsd,
             });
+            queue.push({ type: 'cost_update', record });
             stream.lastResponseId = completion.responseId;
             stream.rawResponses?.push(completion);
             // Some provider adapters report function calls only in the terminal
             // completion rather than as separate stream events. Their reasoning may
             // likewise be terminal-only, so associate it before replaying calls.
+            const toolCalls = [...streamedToolCalls];
             if (!sawToolCall) {
                 for (const item of completion.output) {
                     if (item.type === 'reasoning')
@@ -669,9 +747,11 @@ export class ApplicationRunLoop {
                         continue;
                     pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
                     sawToolCall = true;
-                    await this.#handleToolCall(state, stream, queue, item, toolContext);
+                    toolCalls.push(item);
                 }
             }
+            if (toolCalls.length > 0)
+                await this.#dispatchToolCalls(state, stream, queue, toolCalls, toolContext);
             // A native reasoning item belongs to the completed assistant turn even
             // when no tool call follows it. Commit it before assistant text so both
             // stateless continuation and persisted canonical history retain the
@@ -711,105 +791,154 @@ export class ApplicationRunLoop {
             }
             if (state.pendingApprovals.length > 0) {
                 stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+                this.#turnPaused = true;
                 return finish(stream, state, queue);
             }
             if (!sawToolCall)
                 return finish(stream, state, queue);
         }
     }
-    async #handleToolCall(state, stream, queue, event, toolContext) {
-        const definition = state.agent.tools.find((tool) => tool.name === event.name);
-        const args = parseArguments(event.arguments);
-        const callItem = {
-            type: 'function_call',
-            callId: event.id,
-            name: event.name,
-            arguments: event.arguments,
-        };
-        state.history.push(callItem);
-        state.input.push({ type: 'tool_call', id: event.id, name: event.name, arguments: event.arguments });
-        outputPush(stream, queue, { type: 'item', item: callItem });
-        if (!definition) {
-            const output = `Unknown tool: ${event.name}`;
-            const resultItem = {
-                type: 'function_call_result',
+    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: 'function_call',
                 callId: event.id,
                 name: event.name,
-                output,
+                arguments: event.arguments,
             };
-            state.history.push(resultItem);
-            state.input.push({ type: 'tool_result', id: event.id, output });
-            outputPush(stream, queue, { type: 'item', item: resultItem });
-            return;
-        }
-        // 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.
-        const params = normalizeToolParameters(args, definition.parameters);
-        // 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) {
-            const message = state.approvals.getRejectionMessage(event.name, event.id) ?? 'Tool execution was not approved.';
-            const resultItem = {
-                type: 'function_call_result',
-                callId: event.id,
-                name: event.name,
-                output: message,
-            };
-            state.history.push(resultItem);
-            state.input.push({ type: 'tool_result', id: event.id, output: message });
-            outputPush(stream, queue, { type: 'item', item: resultItem });
-            return;
-        }
-        if (alreadyDecided === true) {
-            const result = await this.#invokeTool(definition, params, toolContext, event.id, state);
-            const output = typeof result === 'string' ? result : JSON.stringify(result);
-            const resultItem = {
-                type: 'function_call_result',
-                callId: event.id,
-                name: event.name,
-                output,
-            };
-            state.history.push(resultItem);
-            state.input.push({ type: 'tool_result', id: event.id, output });
-            outputPush(stream, queue, { type: 'item', item: resultItem });
-            return;
-        }
-        if (await definition.needsApproval(params, toolContext)) {
-            const pending = {
-                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,
-                },
+            state.history.push(callItem);
+            state.input.push({ type: 'tool_call', id: event.id, name: event.name, arguments: event.arguments });
+            outputPush(stream, queue, { type: 'item', item: callItem });
+            return {
+                event,
                 definition,
-                params,
+                parallelSafe: false,
+                status: 'ready',
             };
-            state.pendingApprovals ??= [];
-            if (!state.pendingApproval)
-                state.pendingApproval = pending;
-            state.pendingApprovals.push(pending);
-            stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+        });
+        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.
+            entry.params = normalizeToolParameters(parseArguments(event.arguments), definition.parameters);
+            // 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 = {
+                    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,
+                };
+                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',
+            })),
+        });
+        await this.#settleToolPlan(state, stream, queue, toolContext);
+    }
+    async #settleToolPlan(state, stream, queue, toolContext) {
+        const plan = state.toolPlan;
+        if (!plan)
             return;
+        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 >= this.#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,
+                dispatchOrder: group.map((entry) => entry.event.id),
+            });
+            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()) {
+                    this.#appendToolResult(state, stream, queue, group[index], result.value);
+                }
+            }
+            else {
+                const result = await this.#invokePlannedTool(group[0], toolContext, state);
+                this.#appendToolResult(state, stream, queue, group[0], result);
+            }
+            this.#deps.logDiagnostic?.('tool batch settled', {
+                batchId,
+                settlementOrder: group.map((entry) => entry.event.id),
+            });
         }
-        const result = await this.#invokeTool(definition, params, toolContext, event.id, state);
+    }
+    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);
+    }
+    #appendToolResult(state, stream, queue, entry, result) {
         const output = typeof result === 'string' ? result : JSON.stringify(result);
         const resultItem = {
             type: 'function_call_result',
-            callId: event.id,
-            name: event.name,
+            callId: entry.event.id,
+            name: entry.event.name,
             output,
         };
         state.history.push(resultItem);
-        state.input.push({ type: 'tool_result', id: event.id, output });
+        state.input.push({ type: 'tool_result', id: entry.event.id, output });
         outputPush(stream, queue, { type: 'item', item: resultItem });
     }
     /**
@@ -843,6 +972,9 @@ export class ApplicationRunLoop {
             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 } });
@@ -869,9 +1001,9 @@ export class ApplicationRunLoop {
             return result;
         }
     }
-    #nextRequestId(state) {
-        state.costRequestSeq = (state.costRequestSeq ?? 0) + 1;
-        return `req-${state.turnCount}-${state.costRequestSeq}`;
+    #nextRequestId() {
+        nextCostRequestSeq += 1;
+        return `req-${nextCostRequestSeq}`;
     }
     #appendCostRecord(state, input) {
         const record = computeModelCost({
@@ -886,6 +1018,7 @@ export class ApplicationRunLoop {
             pricingVersion: getCatalogPricingVersion(),
         });
         state.costRecords = [...(state.costRecords ?? []), record];
+        return record;
     }
     async #notifyToolLifecycle(operation) {
         if (!operation)
@@ -1021,6 +1154,17 @@ function parseArguments(value) {
         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;