fix(agent-core): stop canceled parallel tools from starting (#102276)

harjothkhara · steipete · web-flow · commit 85aa26d34f8b · 2026-07-09T09:48:11.000+01:00
* fix(agent-core): skip prepared tools after abort

* docs(agent-core): explain parallel abort guard

* docs(changelog): note parallel cancellation fix

* docs(changelog): leave release notes release-owned

---------

Co-authored-by: Peter Steinberger &lt;steipete@gmail.com&gt;
diff --git a/packages/agent-core/src/agent-loop.test.ts b/packages/agent-core/src/agent-loop.test.ts
@@ -1183,6 +1183,83 @@ describe("agentLoop tool termination", () => {
     expect(events.at(-1)).toMatchObject({ type: "agent_end" });
   });
 
+  it("does not start prepared parallel tools after the run aborts mid-batch", async () => {
+    const controller = new AbortController();
+    const executed: string[] = [];
+    const afterToolCall = vi.fn(async () => undefined);
+    const streamFn: StreamFn = () => {
+      const stream = createAssistantMessageEventStream();
+      queueMicrotask(() => {
+        stream.push({
+          type: "done",
+          reason: "toolUse",
+          message: makeAssistantMessage([
+            { type: "toolCall", id: "call-paid", name: "paid", arguments: {} },
+            { type: "toolCall", id: "call-gated", name: "gated", arguments: {} },
+          ]),
+        });
+        stream.end();
+      });
+      return stream;
+    };
+    const events: AgentEvent[] = [];
+
+    await runAgentLoop(
+      [{ role: "user", content: "abort during parallel tool preparation", timestamp: 1 }],
+      {
+        systemPrompt: "",
+        messages: [],
+        tools: [makeTool("paid", executed), makeTool("gated", executed)],
+      },
+      {
+        ...config,
+        toolExecution: "parallel",
+        beforeToolCall: async ({ toolCall }) => {
+          if (toolCall.name === "gated") {
+            await Promise.resolve();
+            controller.abort(new Error("user aborted"));
+          }
+          return undefined;
+        },
+        afterToolCall,
+      },
+      (event) => {
+        events.push(event);
+      },
+      controller.signal,
+      streamFn,
+    );
+
+    const endEvents = events.filter(
+      (event): event is Extract<AgentEvent, { type: "tool_execution_end" }> =>
+        event.type === "tool_execution_end",
+    );
+
+    expect(executed).toEqual([]);
+    expect(afterToolCall).not.toHaveBeenCalled();
+    expect(endEvents).toHaveLength(2);
+    expect(endEvents).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          toolName: "paid",
+          isError: true,
+          executionStarted: false,
+          result: expect.objectContaining({
+            content: [{ type: "text", text: "Operation aborted" }],
+          }),
+        }),
+        expect.objectContaining({
+          toolName: "gated",
+          isError: true,
+          executionStarted: false,
+          result: expect.objectContaining({
+            content: [{ type: "text", text: "Operation aborted" }],
+          }),
+        }),
+      ]),
+    );
+  });
+
   it("does not request another model turn when an async turn hook aborts the run", async () => {
     const controller = new AbortController();
     let streamCalls = 0;
diff --git a/packages/agent-core/src/agent-loop.ts b/packages/agent-core/src/agent-loop.ts
@@ -793,6 +793,7 @@ type ImmediateToolCallOutcome = {
 type ExecutedToolCallOutcome = {
   result: AgentToolResult<unknown>;
   isError: boolean;
+  executionStarted: boolean;
 };
 
 type FinalizedToolCallOutcome = {
@@ -985,6 +986,16 @@ async function executePreparedToolCall(
   signal: AbortSignal | undefined,
   emit: AgentEventSink,
 ): Promise<ExecutedToolCallOutcome> {
+  // Parallel batches prepare every call first. A later preflight abort must not
+  // let an earlier prepared, side-effectful tool start afterward.
+  if (signal?.aborted) {
+    return {
+      result: createErrorToolResult("Operation aborted"),
+      isError: true,
+      executionStarted: false,
+    };
+  }
+
   const updateEvents: Promise<void>[] = [];
   let acceptingUpdates = true;
 
@@ -1015,13 +1026,14 @@ async function executePreparedToolCall(
     );
     acceptingUpdates = false;
     await Promise.all(updateEvents);
-    return { result, isError: false };
+    return { result, isError: false, executionStarted: true };
   } catch (error) {
     acceptingUpdates = false;
     await Promise.all(updateEvents);
     return {
       result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
       isError: true,
+      executionStarted: true,
     };
   } finally {
     acceptingUpdates = false;
@@ -1039,7 +1051,7 @@ async function finalizeExecutedToolCall(
   let result = executed.result;
   let isError = executed.isError;
 
-  if (config.afterToolCall) {
+  if (executed.executionStarted && config.afterToolCall) {
     try {
       const afterResult = await config.afterToolCall(
         {
@@ -1070,7 +1082,7 @@ async function finalizeExecutedToolCall(
     toolCall: prepared.toolCall,
     result,
     isError,
-    executionStarted: true,
+    executionStarted: executed.executionStarted,
     ...(prepared.tool.hideFromChannelProgress === true ? { hideFromChannelProgress: true } : {}),
   };
 }
