@n8n/agents 0.26.3 → 0.27.1

package/dist/runtime/tools/tool-call-executor.js

@@ -1,51 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolCallExecutor = void 0;
-const json_schema_1 = require("@n8n/ai-utilities/json-schema");
 const delegate_sub_agent_tool_1 = require("./delegate-sub-agent-tool");
 const sub_agent_task_path_1 = require("./sub-agent-task-path");
-const tool_adapter_1 = require("./tool-adapter");
-const tool_result_guard_1 = require("./tool-result-guard");
-const untrusted_tool_output_1 = require("./untrusted-tool-output");
-const abort_1 = require("../../sdk/abort");
-const cancellation_1 = require("../../sdk/cancellation");
-const message_1 = require("../../sdk/message");
-const parse_1 = require("../../utils/parse");
-const zod_1 = require("../../utils/zod");
+const tool_call_runner_1 = require("./tool-call-runner");
 const execution_counter_1 = require("../loop/execution-counter");
-const runtime_helpers_1 = require("../loop/runtime-helpers");
 const messages_1 = require("../model/messages");
-function isDeniedApprovalResumeData(value) {
-    return value !== null && typeof value === 'object' && Reflect.get(value, 'approved') === false;
-}
-function shouldEmitToolExecutionStart(tool, resumeData) {
-    if (!tool.approval)
-        return true;
-    if (!tool.approval.required && tool.approval.conditional !== true)
-        return true;
-    if (resumeData === undefined)
-        return false;
-    return !isDeniedApprovalResumeData(resumeData);
-}
-function getToolResumeJsonSchema(tool, resumeSchemaOverride) {
-    const resolvedSchema = resumeSchemaOverride ?? tool.resumeSchema;
-    if (!resolvedSchema)
-        return undefined;
-    return (0, zod_1.isZodSchema)(resolvedSchema) ? (0, json_schema_1.zodSchemaToJsonSchema)(resolvedSchema) : resolvedSchema;
-}
 class ToolCallExecutor {
     constructor(deps) {
         this.deps = deps;
-        this.offloadedToolResults = false;
+        this.runner = new tool_call_runner_1.ToolCallRunner(deps);
     }
     get hasOffloadedToolResults() {
-        return this.offloadedToolResults;
-    }
-    get telemetry() {
-        return this.deps.telemetry;
-    }
-    get eventBus() {
-        return this.deps.eventBus;
+        return this.runner.hasOffloadedToolResults;
     }
     get concurrency() {
         return this.deps.concurrency;
@@ -83,425 +50,277 @@ class ToolCallExecutor {
         return batch;
     }
     async iterateToolCallsConcurrent(ctx) {
-        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = ctx;
         const errors = [];
-        const runtimeToolCalls = [];
-        for (const toolCall of toolCalls) {
-            const normalizedInput = (0, messages_1.normalizeToolInputForModel)(toolCall.input);
-            if (!normalizedInput.ok) {
-                const error = new Error(normalizedInput.error);
-                (0, execution_counter_1.incrementToolCallCount)(executionCounter);
-                list.setToolCallError(toolCall.toolCallId, error);
-                errors.push({
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: normalizedInput.input,
-                    error,
-                });
-                continue;
-            }
-            runtimeToolCalls.push({ ...toolCall, input: normalizedInput.input });
-        }
+        const runtimeToolCalls = this.normalizeToolCalls(ctx.toolCalls, ctx, errors);
         const executableCalls = runtimeToolCalls.filter((tc) => !tc.providerExecuted);
         const providerExecutedCount = runtimeToolCalls.length - executableCalls.length;
         for (let i = 0; i < providerExecutedCount; i++) {
-            (0, execution_counter_1.incrementToolCallCount)(executionCounter);
+            (0, execution_counter_1.incrementToolCallCount)(ctx.executionCounter);
         }
         const executableCallsById = new Map(executableCalls.map((tc) => [tc.toolCallId, tc]));
         const unexecutedIds = new Set(executableCalls.map((tc) => tc.toolCallId));
-        const results = [];
-        const suspensions = [];
-        const pending = {};
+        const result = { results: [], suspensions: [], errors, pending: {} };
         for (let batchStart = 0; batchStart < executableCalls.length;) {
             if (ctx.isAborted()) {
-                this.deps.onCancelled();
-                for (const id of unexecutedIds) {
-                    const tc = executableCallsById.get(id);
-                    const modelOutput = '[Skipped: run was aborted]';
-                    list.setToolCallResult(tc.toolCallId, modelOutput, { canceled: true });
-                    results.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: tc.input,
-                        toolEntry: {
-                            tool: tc.toolName,
-                            input: tc.input,
-                            output: modelOutput,
-                            transformed: false,
-                            canceled: true,
-                        },
-                        modelOutput,
-                    });
-                }
-                return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+                this.skipAbortedToolCalls(unexecutedIds, executableCallsById, ctx.list, result.results);
+                return await this.finalizeBatch(result, ctx);
             }
-            const batch = this.takeNextToolCallBatch(executableCalls, batchStart, toolMap);
+            const batch = this.takeNextToolCallBatch(executableCalls, batchStart, ctx.toolMap);
             batchStart += batch.length;
-            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall({
-                toolCallId: tc.toolCallId,
-                toolName: tc.toolName,
-                input: tc.input,
-                toolMap,
-                list,
-                runId,
-                persistence: ctx.persistence,
-                resolvedTelemetry,
-                executionCounter,
-                abortSignal,
-                countToolCall: true,
-            })));
-            for (const tc of batch) {
+            const settled = await this.executeToolCallBatch(batch, ctx);
+            for (const tc of batch)
                 unexecutedIds.delete(tc.toolCallId);
-            }
-            let hasSuspension = false;
-            for (let i = 0; i < settledResults.length; i++) {
-                const result = settledResults[i];
-                const tc = batch[i];
-                const toolInput = tc.input;
-                if (result.status === 'rejected') {
-                    list.setToolCallError(tc.toolCallId, result.reason);
-                    errors.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        error: result.reason,
-                    });
-                }
-                else if (result.value.outcome === 'suspended') {
-                    hasSuspension = true;
-                    suspensions.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        payload: result.value.payload,
-                        resumeSchema: result.value.resumeSchema,
-                    });
-                    pending[tc.toolCallId] = {
-                        suspended: true,
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        suspendPayload: result.value.payload,
-                        resumeSchema: result.value.resumeSchema,
-                        ...(result.value.continuation !== undefined
-                            ? { continuation: result.value.continuation }
-                            : {}),
-                        runId,
-                    };
-                }
-                else if (result.value.outcome === 'success') {
-                    results.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        toolEntry: result.value.toolEntry,
-                        modelOutput: result.value.modelOutput,
-                        customMessage: result.value.customMessage,
-                        ...(result.value.mcpServerName !== undefined
-                            ? { mcpServerName: result.value.mcpServerName }
-                            : {}),
-                    });
-                }
-                else if (result.value.outcome === 'cancelled') {
-                    results.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        toolEntry: result.value.toolEntry,
-                        modelOutput: result.value.modelOutput,
-                    });
-                }
-                else if (result.value.outcome === 'error') {
-                    errors.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        error: result.value.error,
-                    });
-                }
-                else if (result.value.outcome === 'noop') {
-                }
-            }
+            const hasSuspension = this.collectBatchResults(batch, settled, result, ctx);
             if (ctx.isAborted()) {
-                this.deps.onCancelled();
-                for (const id of unexecutedIds) {
-                    const tc = executableCallsById.get(id);
-                    const modelOutput = '[Skipped: run was aborted]';
-                    list.setToolCallResult(tc.toolCallId, modelOutput, { canceled: true });
-                    results.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: tc.input,
-                        toolEntry: {
-                            tool: tc.toolName,
-                            input: tc.input,
-                            output: modelOutput,
-                            transformed: false,
-                            canceled: true,
-                        },
-                        modelOutput,
-                    });
-                }
-                return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+                this.skipAbortedToolCalls(unexecutedIds, executableCallsById, ctx.list, result.results);
+                return await this.finalizeBatch(result, ctx);
             }
             if (hasSuspension) {
-                for (const id of unexecutedIds) {
-                    const tc = executableCallsById.get(id);
-                    pending[tc.toolCallId] = {
-                        suspended: false,
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: tc.input,
-                    };
-                }
+                this.retainUnexecutedToolCalls(unexecutedIds, executableCallsById, result.pending);
                 break;
             }
         }
-        return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+        return await this.finalizeBatch(result, ctx);
     }
-    async iteratePendingToolCallsConcurrent(ctx) {
-        const { pendingResume, toolMap, list, runId, persistence, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = ctx;
-        const resumedId = pendingResume.resumeToolCallId;
-        const resumedEntry = pendingResume.pendingToolCalls[resumedId];
-        if (!resumedEntry) {
-            throw new Error(`No pending tool call found for toolCallId: ${resumedId}`);
-        }
-        const resumedToolName = resumedEntry.toolName;
-        const results = [];
-        const suspensions = [];
-        const errors = [];
-        const pending = {};
-        const processResult = await this.processToolCall(this.pendingToolCallParams(resumedEntry, ctx, pendingResume.resumeData));
-        if (processResult.outcome === 'suspended') {
-            pending[resumedId] = {
-                suspended: true,
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                suspendPayload: processResult.payload,
-                resumeSchema: processResult.resumeSchema,
-                ...(processResult.continuation !== undefined
-                    ? { continuation: processResult.continuation }
-                    : {}),
-                runId,
-            };
-            suspensions.push({
-                toolCallId: resumedId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                payload: processResult.payload,
-                resumeSchema: processResult.resumeSchema,
-            });
-        }
-        else if (processResult.outcome === 'success') {
-            results.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                toolEntry: processResult.toolEntry,
-                modelOutput: processResult.modelOutput,
-                customMessage: processResult.customMessage,
-                ...(processResult.mcpServerName !== undefined
-                    ? { mcpServerName: processResult.mcpServerName }
-                    : {}),
-            });
-        }
-        else if (processResult.outcome === 'cancelled') {
-            results.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                toolEntry: processResult.toolEntry,
-                modelOutput: processResult.modelOutput,
-            });
-            list.addInput([
-                { role: 'user', content: [{ type: 'text', text: processResult.userMessage }] },
-            ]);
-            for (const id of Object.keys(pendingResume.pendingToolCalls)) {
-                if (id !== resumedId) {
-                    const siblingEntry = pendingResume.pendingToolCalls[id];
-                    const siblingTool = toolMap.get(siblingEntry.toolName);
-                    const siblingParams = this.pendingToolCallParams(siblingEntry, ctx, pendingResume.resumeData);
-                    if (siblingEntry.suspended && siblingTool?.onCancellation) {
-                        try {
-                            await this.runCancellationCleanup(siblingParams, siblingTool, processResult.userMessage);
-                        }
-                        catch {
-                            this.retainPendingToolCall(id, siblingEntry, pending, suspensions);
-                            continue;
-                        }
-                    }
-                    const modelOutput = '[Skipped: a sibling tool call was cancelled]';
-                    list.setToolCallResult(id, modelOutput, {
-                        canceled: true,
-                    });
-                    results.push({
-                        toolCallId: siblingEntry.toolCallId,
-                        toolName: siblingEntry.toolName,
-                        input: siblingEntry.input,
-                        toolEntry: {
-                            tool: siblingEntry.toolName,
-                            input: siblingEntry.input,
-                            output: modelOutput,
-                            transformed: false,
-                            canceled: true,
-                        },
-                        modelOutput,
-                    });
-                }
+    normalizeToolCalls(toolCalls, ctx, errors) {
+        const calls = [];
+        for (const toolCall of toolCalls) {
+            const normalizedInput = (0, messages_1.normalizeToolInputForModel)(toolCall.input);
+            if (!normalizedInput.ok) {
+                const error = new Error(normalizedInput.error);
+                (0, execution_counter_1.incrementToolCallCount)(ctx.executionCounter);
+                ctx.list.setToolCallError(toolCall.toolCallId, error);
+                errors.push({
+                    toolCallId: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    input: normalizedInput.input,
+                    error,
+                });
+                continue;
             }
-            return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+            calls.push({ ...toolCall, input: normalizedInput.input });
         }
-        else if (processResult.outcome === 'retryable-error') {
-            for (const [id, entry] of Object.entries(pendingResume.pendingToolCalls)) {
-                this.retainPendingToolCall(id, entry, pending, suspensions);
-            }
-            return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+        return calls;
+    }
+    async executeToolCallBatch(batch, ctx) {
+        return await Promise.allSettled(batch.map(async (tc) => await this.runner.processToolCall({
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.input,
+            toolMap: ctx.toolMap,
+            list: ctx.list,
+            runId: ctx.runId,
+            persistence: ctx.persistence,
+            resolvedTelemetry: ctx.telemetry,
+            executionCounter: ctx.executionCounter,
+            abortSignal: ctx.abortSignal,
+            countToolCall: true,
+        })));
+    }
+    collectBatchResults(calls, settled, batch, ctx) {
+        let hasSuspension = false;
+        for (let i = 0; i < settled.length; i++) {
+            if (this.collectSettledToolCall(calls[i], settled[i], batch, ctx))
+                hasSuspension = true;
         }
-        else if (processResult.outcome === 'error') {
-            errors.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                error: processResult.error,
+        return hasSuspension;
+    }
+    collectSettledToolCall(call, result, batch, ctx) {
+        if (result.status === 'rejected') {
+            ctx.list.setToolCallError(call.toolCallId, result.reason);
+            batch.errors.push({
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: call.input,
+                error: result.reason,
             });
-        }
-        else if (processResult.outcome === 'noop') {
-        }
-        const unexecuted = [];
-        for (const [id, entry] of Object.entries(pendingResume.pendingToolCalls)) {
-            if (id === resumedId)
-                continue;
-            if (entry.suspended) {
-                this.retainPendingToolCall(id, entry, pending, suspensions);
-            }
-            else {
-                unexecuted.push({
-                    toolCallId: id,
-                    toolName: entry.toolName,
-                    input: entry.input,
+            return false;
+        }
+        const outcome = result.value;
+        switch (outcome.outcome) {
+            case 'suspended':
+                batch.suspensions.push(this.buildToolCallSuspension(call, outcome));
+                batch.pending[call.toolCallId] = this.buildPendingToolCall(call, outcome, ctx.runId);
+                return true;
+            case 'success':
+            case 'cancelled':
+                this.appendCompletedToolCall(call, outcome, batch.results);
+                break;
+            case 'error':
+                batch.errors.push({
+                    toolCallId: call.toolCallId,
+                    toolName: call.toolName,
+                    input: call.input,
+                    error: outcome.error,
                 });
-            }
+                break;
         }
-        if (unexecuted.length > 0) {
-            const batch = await this.iterateToolCallsConcurrent({
-                toolCalls: unexecuted,
-                toolMap,
-                list,
-                runId,
-                persistence,
-                telemetry: resolvedTelemetry,
-                executionCounter,
-                abortSignal,
-                isAborted: ctx.isAborted,
-            });
-            results.push(...batch.results);
-            suspensions.push(...batch.suspensions);
-            errors.push(...batch.errors);
-            Object.assign(pending, batch.pending);
+        return false;
+    }
+    buildToolCallSuspension(call, outcome) {
+        return {
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            payload: outcome.payload,
+            resumeSchema: outcome.resumeSchema,
+        };
+    }
+    buildPendingToolCall(call, outcome, runId) {
+        return {
+            suspended: true,
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            suspendPayload: outcome.payload,
+            resumeSchema: outcome.resumeSchema,
+            ...(outcome.continuation !== undefined ? { continuation: outcome.continuation } : {}),
+            runId,
+        };
+    }
+    appendCompletedToolCall(call, outcome, results) {
+        const result = {
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            toolEntry: outcome.toolEntry,
+            modelOutput: outcome.modelOutput,
+        };
+        if (outcome.outcome === 'success') {
+            result.customMessage = outcome.customMessage;
+            if (outcome.mcpServerName !== undefined)
+                result.mcpServerName = outcome.mcpServerName;
         }
-        return await this.finalizeBatch({ results, suspensions, errors, pending }, ctx);
+        results.push(result);
     }
-    async processToolCall(params) {
-        const { toolName, toolMap, list, toolCallId, resumeData } = params;
-        const builtTool = toolMap.get(toolName);
-        if (!builtTool) {
-            return await this.toolError(params, new Error(`Tool ${toolName} not found`));
+    skipAbortedToolCalls(ids, calls, list, results) {
+        this.deps.onCancelled();
+        for (const id of ids) {
+            const call = calls.get(id);
+            const modelOutput = '[Skipped: run was aborted]';
+            list.setToolCallResult(call.toolCallId, modelOutput, { canceled: true });
+            results.push(this.buildSkippedToolResult(call, modelOutput));
         }
-        const settledBlock = this.findSettledToolCall(list, toolCallId);
-        if (settledBlock) {
-            return this.completeSettledToolCall(params, settledBlock);
+    }
+    buildSkippedToolResult(call, modelOutput) {
+        return {
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            input: call.input,
+            toolEntry: {
+                tool: call.toolName,
+                input: call.input,
+                output: modelOutput,
+                transformed: false,
+                canceled: true,
+            },
+            modelOutput,
+        };
+    }
+    retainUnexecutedToolCalls(ids, calls, pending) {
+        for (const id of ids) {
+            const call = calls.get(id);
+            pending[call.toolCallId] = {
+                suspended: false,
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: call.input,
+            };
         }
-        if ((0, cancellation_1.isCancellation)(resumeData) && !builtTool.handleCancellation) {
-            try {
-                await this.runCancellationCleanup(params, builtTool, resumeData.message);
-            }
-            catch {
-                return { outcome: 'retryable-error' };
+    }
+    async iteratePendingToolCallsConcurrent(ctx) {
+        const { pendingResume } = ctx;
+        const resumedId = pendingResume.resumeToolCallId;
+        const resumedEntry = pendingResume.pendingToolCalls[resumedId];
+        if (!resumedEntry)
+            throw new Error(`No pending tool call found for toolCallId: ${resumedId}`);
+        const batch = { results: [], suspensions: [], errors: [], pending: {} };
+        const outcome = await this.runner.processToolCall(this.pendingToolCallParams(resumedEntry, ctx, pendingResume.resumeData));
+        if (outcome.outcome === 'cancelled') {
+            this.appendCompletedToolCall(resumedEntry, outcome, batch.results);
+            ctx.list.addInput([{ role: 'user', content: [{ type: 'text', text: outcome.userMessage }] }]);
+            await this.cancelSiblingToolCalls(ctx, batch, outcome.userMessage);
+            return await this.finalizeBatch(batch, ctx);
+        }
+        if (outcome.outcome === 'retryable-error') {
+            for (const [id, entry] of Object.entries(pendingResume.pendingToolCalls)) {
+                this.retainPendingToolCall(id, entry, batch.pending, batch.suspensions);
             }
-            return this.buildCancelledOutcome(params, resumeData.message);
-        }
-        if (params.countToolCall ?? true) {
-            (0, execution_counter_1.incrementToolCallCount)(params.executionCounter);
-        }
-        const validation = await this.validateToolInput(params, builtTool);
-        if (!validation.ok)
-            return validation.outcome;
-        const input = validation.input;
-        if (shouldEmitToolExecutionStart(builtTool, resumeData)) {
-            this.eventBus.emit({
-                type: "tool_execution_start",
-                toolCallId,
-                toolName,
-                args: input,
-            });
+            return await this.finalizeBatch(batch, ctx);
         }
-        let toolResult;
-        let interruptedSuspendPayload;
-        let interruptedSuspendOptions;
-        let didSuspend = false;
-        let abortObserved = false;
-        let suspensionCleanup;
-        const cleanupInterruptedSuspension = async () => {
-            suspensionCleanup ??= this.runCancellationCleanup({
-                ...params,
-                input,
-                suspendPayload: interruptedSuspendPayload,
-                continuation: interruptedSuspendOptions?.continuation,
-                resumeSchema: getToolResumeJsonSchema(builtTool, interruptedSuspendOptions?.resumeSchema),
-            }, builtTool, 'Run aborted').catch(() => undefined);
-            await suspensionCleanup;
-        };
-        try {
-            toolResult = await this.runToolHandler(params, builtTool, input, async (payload, options) => {
-                didSuspend = true;
-                interruptedSuspendPayload = payload;
-                interruptedSuspendOptions = options;
-                if (abortObserved || params.abortSignal?.aborted) {
-                    await cleanupInterruptedSuspension();
-                }
-            });
+        this.collectResumedToolCall(resumedId, resumedEntry, outcome, batch, ctx.runId);
+        await this.executeRemainingToolCalls(ctx, batch);
+        return await this.finalizeBatch(batch, ctx);
+    }
+    collectResumedToolCall(id, entry, outcome, batch, runId) {
+        switch (outcome.outcome) {
+            case 'suspended':
+                batch.pending[id] = this.buildPendingToolCall(entry, outcome, runId);
+                batch.suspensions.push(this.buildToolCallSuspension({ ...entry, toolCallId: id }, outcome));
+                break;
+            case 'success':
+                this.appendCompletedToolCall(entry, outcome, batch.results);
+                break;
+            case 'error':
+                batch.errors.push({
+                    toolCallId: entry.toolCallId,
+                    toolName: entry.toolName,
+                    input: entry.input,
+                    error: outcome.error,
+                });
+                break;
         }
-        catch (error) {
-            if ((0, abort_1.isAbortError)(error) || params.abortSignal?.aborted) {
-                abortObserved = true;
-                if (didSuspend) {
-                    await cleanupInterruptedSuspension();
+    }
+    async cancelSiblingToolCalls(ctx, batch, userMessage) {
+        for (const id of Object.keys(ctx.pendingResume.pendingToolCalls)) {
+            if (id === ctx.pendingResume.resumeToolCallId)
+                continue;
+            const entry = ctx.pendingResume.pendingToolCalls[id];
+            const tool = ctx.toolMap.get(entry.toolName);
+            const params = this.pendingToolCallParams(entry, ctx, ctx.pendingResume.resumeData);
+            if (entry.suspended && tool?.onCancellation) {
+                try {
+                    await this.runner.runCancellationCleanup(params, tool, userMessage);
                 }
-                else if (params.suspendPayload !== undefined || params.continuation !== undefined) {
-                    try {
-                        await this.runCancellationCleanup({ ...params, input }, builtTool, 'Run aborted');
-                    }
-                    catch {
-                    }
+                catch {
+                    this.retainPendingToolCall(id, entry, batch.pending, batch.suspensions);
+                    continue;
                 }
-                this.deps.onCancelled();
-                return this.buildCancelledOutcome(params, 'Run aborted');
             }
-            return await this.toolError(params, error, builtTool);
-        }
-        if ((0, tool_adapter_1.isSuspendedToolResult)(toolResult)) {
-            return await this.buildSuspendedOutcome(params, builtTool, toolResult);
+            const modelOutput = '[Skipped: a sibling tool call was cancelled]';
+            ctx.list.setToolCallResult(id, modelOutput, { canceled: true });
+            batch.results.push(this.buildSkippedToolResult(entry, modelOutput));
         }
-        return await this.buildSuccessOutcome(params, builtTool, input, toolResult);
     }
-    async runCancellationCleanup(params, builtTool, message) {
-        if (!builtTool.onCancellation)
+    async executeRemainingToolCalls(ctx, result) {
+        const unexecuted = [];
+        for (const [id, entry] of Object.entries(ctx.pendingResume.pendingToolCalls)) {
+            if (id === ctx.pendingResume.resumeToolCallId)
+                continue;
+            if (entry.suspended) {
+                this.retainPendingToolCall(id, entry, result.pending, result.suspensions);
+            }
+            else {
+                unexecuted.push({ toolCallId: id, toolName: entry.toolName, input: entry.input });
+            }
+        }
+        if (unexecuted.length === 0)
             return;
-        await builtTool.onCancellation(params.input, {
-            cancellation: { message },
-            toolCallId: params.toolCallId,
-            toolName: params.toolName,
-            runId: params.runId,
-            persistence: params.persistence,
-            parentTelemetry: params.resolvedTelemetry,
-            emitEvent: (event) => this.eventBus.emit(event),
-            abortSignal: params.abortSignal,
-            executionCounter: params.executionCounter,
-            suspendPayload: params.suspendPayload,
-            continuation: params.continuation,
-            resumeSchema: params.resumeSchema,
+        const batch = await this.iterateToolCallsConcurrent({
+            toolCalls: unexecuted,
+            toolMap: ctx.toolMap,
+            list: ctx.list,
+            runId: ctx.runId,
+            persistence: ctx.persistence,
+            telemetry: ctx.telemetry,
+            executionCounter: ctx.executionCounter,
+            abortSignal: ctx.abortSignal,
+            isAborted: ctx.isAborted,
         });
+        result.results.push(...batch.results);
+        result.suspensions.push(...batch.suspensions);
+        result.errors.push(...batch.errors);
+        Object.assign(result.pending, batch.pending);
     }
     async cleanupPendingToolCalls(pending, ctx, message = 'Run aborted') {
         for (const entry of Object.values(pending)) {
@@ -511,7 +330,7 @@ class ToolCallExecutor {
             if (!tool?.onCancellation)
                 continue;
             try {
-                await this.runCancellationCleanup(this.pendingToolCallParams(entry, ctx), tool, message);
+                await this.runner.runCancellationCleanup(this.pendingToolCallParams(entry, ctx), tool, message);
             }
             catch {
             }
@@ -558,168 +377,6 @@ class ToolCallExecutor {
             resumeSchema: entry.resumeSchema,
         });
     }
-    async toolError(params, error, builtTool) {
-        this.eventBus.emit({
-            type: "tool_execution_end",
-            toolCallId: params.toolCallId,
-            toolName: params.toolName,
-            result: error,
-            isError: true,
-        });
-        const errorText = (0, runtime_helpers_1.stringifyError)(error);
-        const guardedError = await (0, tool_result_guard_1.guardToolErrorForModel)(builtTool?.outputTrust === 'untrusted'
-            ? (0, untrusted_tool_output_1.protectUntrustedToolError)(errorText, builtTool)
-            : errorText, this.deps.tokenCounter, this.getResultStorage(params));
-        params.list.setToolCallError(params.toolCallId, guardedError);
-        return { outcome: 'error', error };
-    }
-    findSettledToolCall(list, toolCallId) {
-        return list
-            .responseDelta()
-            .flatMap((m) => ((0, message_1.isLlmMessage)(m) && 'content' in m ? m.content : []))
-            .find((c) => c.type === 'tool-call' && c.toolCallId === toolCallId && c.state !== 'pending');
-    }
-    completeSettledToolCall(params, settledBlock) {
-        const settledResult = settledBlock.state === 'resolved' ? settledBlock.output : settledBlock.error;
-        this.eventBus.emit({
-            type: "tool_execution_end",
-            toolCallId: params.toolCallId,
-            toolName: params.toolName,
-            result: settledResult,
-            isError: settledBlock.state === 'rejected',
-        });
-        return { outcome: 'noop' };
-    }
-    buildCancelledOutcome(params, userMessage) {
-        const { toolCallId, toolName, input, list } = params;
-        const modelOutput = `[Tool call cancelled. User said: "${userMessage}"]`;
-        this.eventBus.emit({
-            type: "tool_execution_end",
-            toolCallId,
-            toolName,
-            result: modelOutput,
-            isError: false,
-        });
-        list.setToolCallResult(toolCallId, modelOutput, { canceled: true });
-        return {
-            outcome: 'cancelled',
-            toolEntry: { tool: toolName, input, output: modelOutput, transformed: false, canceled: true },
-            modelOutput,
-            userMessage,
-            canceled: true,
-        };
-    }
-    async validateToolInput(params, builtTool) {
-        if (!builtTool.inputSchema)
-            return { ok: true, input: params.input };
-        const result = await (0, parse_1.parseWithSchema)(builtTool.inputSchema, params.input);
-        if (!result.success) {
-            const reason = result.schemaInvalid
-                ? `Tool ${params.toolName} has an input schema that could not be compiled: ${result.error}`
-                : `Invalid tool input: ${result.error}`;
-            return { ok: false, outcome: await this.toolError(params, new Error(reason)) };
-        }
-        return { ok: true, input: result.data };
-    }
-    async runToolHandler(params, builtTool, input, onSuspend) {
-        const { toolCallId, toolName, runId, persistence, resumeData, resolvedTelemetry, executionCounter, abortSignal, suspendPayload, continuation, resumeSchema, } = params;
-        return await this.telemetry.withToolSpan(toolCallId, toolName, input, resolvedTelemetry, async () => await (0, abort_1.raceWithAbort)(async () => await (0, tool_adapter_1.executeTool)(input, builtTool, resumeData, resolvedTelemetry, toolCallId, {
-            runId,
-            persistence,
-            ...(this.deps.loadSkill ? { loadSkill: this.deps.loadSkill } : {}),
-            emitEvent: (event) => this.eventBus.emit(event),
-            abortSignal,
-            executionCounter,
-            suspendPayload,
-            continuation,
-            resumeSchema,
-            onSuspend,
-        }), abortSignal));
-    }
-    async buildSuspendedOutcome(params, builtTool, toolResult) {
-        if (builtTool.suspendSchema) {
-            const parseResult = await (0, parse_1.parseWithSchema)(builtTool.suspendSchema, toolResult.payload);
-            if (!parseResult.success) {
-                return await this.toolError(params, new Error(`Invalid suspend payload: ${parseResult.error}`));
-            }
-            toolResult.payload = parseResult.data;
-        }
-        const resumeSchema = getToolResumeJsonSchema(builtTool, toolResult.resumeSchema);
-        if (!resumeSchema) {
-            return await this.toolError(params, new Error(`Tool ${params.toolName} has no resume schema`));
-        }
-        return {
-            outcome: 'suspended',
-            payload: toolResult.payload,
-            resumeSchema,
-            ...(toolResult.continuation !== undefined ? { continuation: toolResult.continuation } : {}),
-        };
-    }
-    async buildSuccessOutcome(params, builtTool, input, toolResult) {
-        const { toolCallId, toolName, list } = params;
-        let modelResult;
-        try {
-            modelResult = builtTool.toModelOutput ? builtTool.toModelOutput(toolResult) : toolResult;
-            if (builtTool.outputTrust === 'untrusted') {
-                modelResult = (0, untrusted_tool_output_1.protectUntrustedToolResult)(modelResult, builtTool);
-            }
-        }
-        catch (error) {
-            return await this.toolError(params, error, builtTool);
-        }
-        const storage = this.getResultStorage(params);
-        const guardedResult = await (0, tool_result_guard_1.guardToolResultForModel)(modelResult, this.deps.tokenCounter, storage);
-        this.eventBus.emit({
-            type: "tool_execution_end",
-            toolCallId,
-            toolName,
-            result: toolResult,
-            isError: false,
-        });
-        list.setToolCallResult(toolCallId, guardedResult.historyOutput);
-        let customMessage = await builtTool.toMessage?.(toolResult);
-        if (customMessage && builtTool.outputTrust === 'untrusted') {
-            customMessage = (0, untrusted_tool_output_1.protectUntrustedToolMessage)(customMessage, builtTool);
-        }
-        let guardedCustomMessage = customMessage
-            ? await (0, tool_result_guard_1.guardToolMessageForModel)(customMessage, this.deps.tokenCounter, storage)
-            : undefined;
-        if (guardedCustomMessage && 'role' in guardedCustomMessage) {
-            guardedCustomMessage = {
-                ...guardedCustomMessage,
-                origin: { kind: 'tool', toolName },
-            };
-        }
-        if (guardedCustomMessage) {
-            list.addResponse([guardedCustomMessage]);
-        }
-        return {
-            outcome: 'success',
-            toolEntry: {
-                tool: toolName,
-                input,
-                output: toolResult,
-                transformed: !!builtTool.toModelOutput,
-            },
-            modelOutput: guardedResult.wireOutput,
-            customMessage: guardedCustomMessage,
-            ...(builtTool.mcpServerName !== undefined ? { mcpServerName: builtTool.mcpServerName } : {}),
-        };
-    }
-    getResultStorage(params) {
-        const filesystem = this.deps.workspaceFilesystem;
-        if (!filesystem)
-            return undefined;
-        return {
-            filesystem,
-            runId: params.runId,
-            toolCallId: params.toolCallId,
-            onOffloaded: () => {
-                this.offloadedToolResults = true;
-            },
-            ...(params.abortSignal ? { abortSignal: params.abortSignal } : {}),
-        };
-    }
 }
 exports.ToolCallExecutor = ToolCallExecutor;
 //# sourceMappingURL=tool-call-executor.js.map