@librechat/agents 3.1.87 → 3.1.89

package/src/__tests__/stream.eagerEventExecution.test.ts

@@ -11,7 +11,7 @@ import {
 } from '@/common';
 import { HandlerRegistry } from '@/events';
 import * as events from '@/utils/events';
-import { ChatModelStreamHandler } from '@/stream';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
@@ -71,7 +71,8 @@ function createGraph(overrides: Partial<StandardGraph> = {}): StandardGraph {
         (details as t.StepDetails).type === StepTypes.TOOL_CALLS &&
         Array.isArray((details as t.ToolCallsDetails).tool_calls)
       ) {
-        for (const toolCall of (details as t.ToolCallsDetails).tool_calls ?? []) {
+        for (const toolCall of (details as t.ToolCallsDetails).tool_calls ??
+          []) {
           if (toolCall.id != null && toolCall.id !== '') {
             graph.toolCallStepIds.set(toolCall.id, id);
           }
@@ -110,8 +111,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('prestarts a complete event-driven tool call from the stream', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -124,8 +126,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -162,11 +163,65 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     expect(graph.toolCallStepIds.has('call_weather')).toBe(true);
   });
 
+  it('prestarts when subagent callback forwarding can execute tools without a handler registry', async () => {
+    const graph = createGraph({
+      handlerRegistry: undefined,
+      eventToolExecutionAvailable: true,
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve([
+          {
+            toolCallId: 'call_weather',
+            status: 'success',
+            content: 'sunny',
+          },
+        ]);
+      });
+
+    await new ChatModelStreamHandler().handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: { city: 'NYC' },
+            },
+          ],
+          response_metadata: finalToolCallResponseMetadata,
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent' },
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
+      id: 'call_weather',
+      name: 'weather',
+      args: { city: 'NYC' },
+      stepId: expect.stringMatching(/^step_/),
+      turn: 0,
+    });
+    expect(graph.eagerEventToolExecutions.has('call_weather')).toBe(true);
+  });
+
   it('does not prestart parseable tool calls before a final tool-call signal', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -179,8 +234,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -248,8 +302,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       ) as unknown as StandardGraph['getAgentContext'],
     });
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -262,8 +317,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `${request.name} result`,
           }))
         );
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -308,7 +362,8 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       }),
     ]);
     const weatherExecution = graph.eagerEventToolExecutions.get('call_weather');
-    const calendarExecution = graph.eagerEventToolExecutions.get('call_calendar');
+    const calendarExecution =
+      graph.eagerEventToolExecutions.get('call_calendar');
     expect(weatherExecution).toMatchObject({
       toolCallId: 'call_weather',
       toolName: 'weather',
@@ -325,8 +380,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('assigns same-tool eager turns in model emission order', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -339,8 +395,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `${request.args.city} weather`,
           }))
         );
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -371,10 +426,12 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       0, 1,
     ]);
     expect(graph.eagerEventToolUsageCount.get('weather')).toBe(2);
-    expect(graph.eagerEventToolExecutions.get('call_weather_1')?.request.turn)
-      .toBe(0);
-    expect(graph.eagerEventToolExecutions.get('call_weather_2')?.request.turn)
-      .toBe(1);
+    expect(
+      graph.eagerEventToolExecutions.get('call_weather_1')?.request.turn
+    ).toBe(0);
+    expect(
+      graph.eagerEventToolExecutions.get('call_weather_2')?.request.turn
+    ).toBe(1);
   });
 
   it('scopes eager turn reservation by agent', async () => {
@@ -391,19 +448,21 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     const graph = createGraph({
       getEagerEventToolUsageCount: jest.fn(getUsageCount),
       getAgentContext: jest.fn(
-        (metadata?: Record<string, unknown>): AgentContext => ({
-          provider: Providers.ANTHROPIC,
-          reasoningKey: 'reasoning',
-          toolDefinitions: [{ name: 'weather' }],
-          graphTools: [],
-          agentId:
-            metadata?.langgraph_node === 'agent_2' ? 'agent_2' : 'agent_1',
-        }) as unknown as AgentContext
+        (metadata?: Record<string, unknown>): AgentContext =>
+          ({
+            provider: Providers.ANTHROPIC,
+            reasoningKey: 'reasoning',
+            toolDefinitions: [{ name: 'weather' }],
+            graphTools: [],
+            agentId:
+              metadata?.langgraph_node === 'agent_2' ? 'agent_2' : 'agent_1',
+          }) as unknown as AgentContext
       ),
     });
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -416,8 +475,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'ok',
           }))
         );
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     await handler.handle(
@@ -463,25 +521,27 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     ]);
     expect(usageByAgent.get('agent_1')?.get('weather')).toBe(1);
     expect(usageByAgent.get('agent_2')?.get('weather')).toBe(1);
-    expect(graph.eagerEventToolExecutions.get('call_agent_1_weather')?.request.turn)
-      .toBe(0);
-    expect(graph.eagerEventToolExecutions.get('call_agent_2_weather')?.request.turn)
-      .toBe(0);
+    expect(
+      graph.eagerEventToolExecutions.get('call_agent_1_weather')?.request.turn
+    ).toBe(0);
+    expect(
+      graph.eagerEventToolExecutions.get('call_agent_2_weather')?.request.turn
+    ).toBe(0);
   });
 
   it('skips eager for the whole batch if any call is not request-plannable', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
         const batch = data as t.ToolExecuteBatchRequest;
         toolExecuteCalls.push(batch);
         batch.resolve([]);
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -515,8 +575,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('records complete chunk-only tool calls after creating a tool step', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -529,8 +590,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -554,8 +614,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     expect(toolExecuteCalls).toHaveLength(0);
     expect(graph.toolCallStepIds.has('call_weather')).toBe(true);
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"city":"NYC"}');
   });
 
@@ -572,8 +631,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       ) as unknown as StandardGraph['getAgentContext'],
     });
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -586,8 +646,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -666,9 +725,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       stepId: expect.stringMatching(/^step_/),
       turn: 0,
     });
-    expect(graph.eagerEventToolCallChunks.has(chunkStateKey('step-key', 0))).toBe(
-      false
-    );
+    expect(
+      graph.eagerEventToolCallChunks.has(chunkStateKey('step-key', 0))
+    ).toBe(false);
   });
 
   it('keeps OpenAI Chat Completions streamed chunks on the final tool_calls path', async () => {
@@ -684,8 +743,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       ) as unknown as StandardGraph['getAgentContext'],
     });
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -698,8 +758,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `ok ${call.name}`,
           }))
         );
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -786,8 +845,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('prestarts final tool calls even when the final chunk also has tool-call chunks', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -800,8 +860,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -843,8 +902,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('waits for final tool calls before prestarting streamed chunk calls', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -857,8 +917,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
 
@@ -1033,8 +1092,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
   it('preserves repeated adjacent argument deltas', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -1047,8 +1107,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'ok',
           },
         ]);
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -1127,8 +1186,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
 
     expect(toolExecuteCalls).toHaveLength(0);
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"word":"book"}');
 
     await handler.handle(
@@ -1202,8 +1260,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
 
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('oo');
   });
 
@@ -1249,16 +1306,16 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
 
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"titl');
   });
 
   it('does not prestart from cumulative streamed args before final tool calls', async () => {
     const graph = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -1271,8 +1328,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -1353,8 +1409,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
 
     expect(toolExecuteCalls).toHaveLength(0);
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"city":"NYC","unit":"C"}');
 
     await handler.handle(
@@ -1445,8 +1500,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
 
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"title":"alpha","city":"NYC"}');
   });
 
@@ -1504,8 +1558,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
 
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"word":"book"}');
   });
 
@@ -1590,8 +1643,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
 
     expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))
-        ?.argsText
+      graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 0))?.argsText
     ).toBe('{"city":"NYC"}');
   });
 
@@ -1599,8 +1651,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     const graphA = createGraph();
     const graphB = createGraph();
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -1613,8 +1666,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `${request.id} result`,
           }))
         );
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const sharedChunk = {
@@ -1660,8 +1712,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       ) as unknown as StandardGraph['getAgentContext'],
     });
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -1674,8 +1727,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `ok ${call.name}`,
           }))
         );
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -1732,9 +1784,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     ]);
     expect(graph.eagerEventToolExecutions.has('call_weather')).toBe(true);
     expect(graph.eagerEventToolExecutions.has('call_stock')).toBe(false);
-    expect(graph.eagerEventToolCallChunks.has(chunkStateKey('step-key', 0))).toBe(
-      false
-    );
+    expect(
+      graph.eagerEventToolCallChunks.has(chunkStateKey('step-key', 0))
+    ).toBe(false);
     expect(
       graph.eagerEventToolCallChunks.get(chunkStateKey('step-key', 1))?.argsText
     ).toBe('{"ticker":"C');
@@ -1793,7 +1845,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     expect(graph.eagerEventToolCallChunks.size).toBe(0);
   });
 
-  it('does not seal a streamed tool when the same chunk also carries its own index', async () => {
+  it('emits a completed event when an eager streamed tool result settles', async () => {
     const graph = createGraph({
       getAgentContext: jest.fn(
         (): Partial<AgentContext> => ({
@@ -1805,14 +1857,18 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
         })
       ) as unknown as StandardGraph['getAgentContext'],
     });
-    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    const completedEvents: Array<{ result: t.ToolEndEvent }> = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
+          completedEvents.push(data as { result: t.ToolEndEvent });
+          return;
+        }
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
         const batch = data as t.ToolExecuteBatchRequest;
-        toolExecuteCalls.push(batch);
         batch.resolve(
           batch.toolCalls.map((call) => ({
             toolCallId: call.id,
@@ -1820,8 +1876,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: `ok ${call.name}`,
           }))
         );
-      }
-    );
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -1851,10 +1906,6 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
         chunk: {
           content: '',
           tool_call_chunks: [
-            {
-              args: '',
-              index: 0,
-            },
             {
               id: 'call_stock',
               name: 'stock',
@@ -1868,52 +1919,51 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       graph
     );
 
-    expect(toolExecuteCalls).toHaveLength(0);
+    await graph.eagerEventToolExecutions.get('call_weather')?.promise;
 
-    await handler.handle(
-      GraphEvents.CHAT_MODEL_STREAM,
-      {
-        chunk: {
-          content: '',
-          tool_call_chunks: [
-            {
-              args: 'H"}',
-              index: 1,
-            },
-          ],
-        } as unknown as t.StreamChunk,
+    expect(completedEvents).toHaveLength(1);
+    expect(completedEvents[0].result).toMatchObject({
+      id: expect.stringMatching(/^step_/),
+      type: 'tool_call',
+      eager: true,
+      tool_call: {
+        id: 'call_weather',
+        name: 'weather',
+        args: '{"city":"NYC"}',
+        output: 'ok weather',
+        progress: 1,
       },
-      metadata,
-      graph
-    );
-
-    expect(toolExecuteCalls).toHaveLength(1);
-    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
-      id: 'call_weather',
-      name: 'weather',
-      args: { city: 'NYC' },
     });
+    expect(
+      graph.eagerEventToolExecutions.get('call_weather')?.completionDispatched
+    ).toBe(true);
   });
 
-  it('preserves same-tool turns across per-call streamed eager starts', async () => {
-    const graph = createGraph();
-    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
-        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+  it('does not emit a stale eager completion after the active execution is invalidated', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [{ name: 'weather' }, { name: 'stock' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const completedEvents: Array<{ result: t.ToolEndEvent }> = [];
+    let pendingBatch: t.ToolExecuteBatchRequest | undefined;
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
+          completedEvents.push(data as { result: t.ToolEndEvent });
           return;
         }
-        const batch = data as t.ToolExecuteBatchRequest;
-        toolExecuteCalls.push(batch);
-        batch.resolve(
-          batch.toolCalls.map((call) => ({
-            toolCallId: call.id,
-            status: 'success',
-            content: `ok ${call.args.city}`,
-          }))
-        );
-      }
-    );
+        if (event === GraphEvents.ON_TOOL_EXECUTE) {
+          pendingBatch = data as t.ToolExecuteBatchRequest;
+        }
+      });
 
     const handler = new ChatModelStreamHandler();
     const metadata = { langgraph_node: 'agent' };
@@ -1925,7 +1975,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_weather_1',
+              id: 'call_weather',
               name: 'weather',
               args: '{"city":"NYC"}',
               index: 0,
@@ -1936,7 +1986,6 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       metadata,
       graph
     );
-
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
@@ -1944,9 +1993,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_weather_2',
-              name: 'weather',
-              args: '{"city":"B',
+              id: 'call_stock',
+              name: 'stock',
+              args: '{"ticker":"C',
               index: 1,
             },
           ],
@@ -1956,90 +2005,56 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       graph
     );
 
-    expect(toolExecuteCalls).toHaveLength(1);
-    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
-      id: 'call_weather_1',
-      name: 'weather',
-      args: { city: 'NYC' },
-      turn: 0,
-    });
-
-    await handler.handle(
-      GraphEvents.CHAT_MODEL_STREAM,
-      {
-        chunk: {
-          content: '',
-          tool_call_chunks: [
-            {
-              args: 'oston"}',
-              index: 1,
-            },
-          ],
-        } as unknown as t.StreamChunk,
-      },
-      metadata,
-      graph
-    );
+    const staleRecord = graph.eagerEventToolExecutions.get('call_weather');
+    expect(staleRecord).toBeDefined();
+    expect(pendingBatch?.toolCalls).toHaveLength(1);
 
-    await handler.handle(
-      GraphEvents.CHAT_MODEL_STREAM,
+    graph.eagerEventToolExecutions.delete('call_weather');
+    pendingBatch?.resolve([
       {
-        chunk: {
-          content: '',
-          tool_calls: [
-            {
-              id: 'call_weather_1',
-              name: 'weather',
-              args: { city: 'NYC' },
-            },
-            {
-              id: 'call_weather_2',
-              name: 'weather',
-              args: { city: 'Boston' },
-            },
-          ],
-          response_metadata: finalToolCallResponseMetadata,
-        } as unknown as t.StreamChunk,
+        toolCallId: 'call_weather',
+        status: 'success',
+        content: 'stale weather',
       },
-      metadata,
-      graph
-    );
+    ]);
+    await staleRecord?.promise;
 
-    expect(toolExecuteCalls).toHaveLength(2);
-    expect(toolExecuteCalls[1].toolCalls[0]).toMatchObject({
-      id: 'call_weather_2',
-      name: 'weather',
-      args: { city: 'Boston' },
-      turn: 1,
-    });
-    expect(graph.eagerEventToolUsageCount.get('weather')).toBe(2);
+    expect(completedEvents).toHaveLength(0);
+    expect(staleRecord?.completionDispatched).toBeUndefined();
   });
 
-  it('scopes streamed chunk accumulation by step key', async () => {
+  it('does not mark eager completion dispatched when event delivery is swallowed', async () => {
     const graph = createGraph({
-      getStepKey: jest.fn((metadata?: Record<string, unknown>) =>
-        String(metadata?.langgraph_node ?? 'step-key')
-      ),
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [{ name: 'weather' }, { name: 'stock' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
     });
-    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
-        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
-          return;
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<boolean | void> => {
+        if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
+          return false;
         }
-        const batch = data as t.ToolExecuteBatchRequest;
-        toolExecuteCalls.push(batch);
-        batch.resolve(
-          batch.toolCalls.map((call) => ({
-            toolCallId: call.id,
-            status: 'success',
-            content: `ok ${call.name}`,
-          }))
-        );
-      }
-    );
+        if (event === GraphEvents.ON_TOOL_EXECUTE) {
+          const batch = data as t.ToolExecuteBatchRequest;
+          batch.resolve([
+            {
+              toolCallId: 'call_weather',
+              status: 'success',
+              content: 'weather result',
+            },
+          ]);
+        }
+      });
 
     const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
 
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
@@ -2048,18 +2063,17 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_agent_a',
+              id: 'call_weather',
               name: 'weather',
-              args: '{"city":"N',
+              args: '{"city":"NYC"}',
               index: 0,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent_a' },
+      metadata,
       graph
     );
-
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
@@ -2067,18 +2081,808 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_agent_b',
-              name: 'weather',
-              args: '{"city":"S',
-              index: 0,
+              id: 'call_stock',
+              name: 'stock',
+              args: '{"ticker":"C',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    const record = graph.eagerEventToolExecutions.get('call_weather');
+    await record?.promise;
+
+    expect(record?.completionDispatched).toBeUndefined();
+  });
+
+  it('does not overwrite a completed tool output with later streamed deltas', () => {
+    const { contentParts, aggregateContent } = createContentAggregator();
+
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: {
+        id: 'step_weather',
+        type: StepTypes.TOOL_CALLS,
+        index: 0,
+        stepDetails: {
+          type: StepTypes.TOOL_CALLS,
+          tool_calls: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: {},
+            },
+          ],
+        },
+        usage: null,
+      } as t.RunStep,
+    });
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP_COMPLETED,
+      data: {
+        result: {
+          id: 'step_weather',
+          index: 0,
+          type: 'tool_call',
+          tool_call: {
+            id: 'call_weather',
+            name: 'weather',
+            args: '{"city":"NYC"}',
+            output: 'sunny',
+            progress: 1,
+          } as t.ProcessedToolCall,
+        },
+      } as { result: t.ToolEndEvent },
+    });
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP_DELTA,
+      data: {
+        id: 'step_weather',
+        delta: {
+          type: StepTypes.TOOL_CALLS,
+          tool_calls: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC revised"}',
+            },
+          ],
+        },
+      } as t.RunStepDeltaEvent,
+    });
+
+    expect(contentParts[0]).toMatchObject({
+      type: ContentTypes.TOOL_CALL,
+      tool_call: {
+        id: 'call_weather',
+        name: 'weather',
+        args: '{"city":"NYC"}',
+        output: 'sunny',
+        progress: 1,
+      },
+    });
+  });
+
+  it('does not use next-index sealing for Moonshot streamed tool chunks', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.MOONSHOT,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [{ name: 'weather' }, { name: 'stock' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_stock',
+              name: 'stock',
+              args: '{"ticker":"C',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(0);
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
+    expect(graph.eagerEventToolCallChunks.size).toBe(0);
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: { city: 'NYC revised' },
+            },
+            {
+              id: 'call_stock',
+              name: 'stock',
+              args: { ticker: 'CH' },
+            },
+          ],
+          response_metadata: finalToolCallResponseMetadata,
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls).toEqual([
+      expect.objectContaining({
+        id: 'call_weather',
+        name: 'weather',
+        args: { city: 'NYC revised' },
+      }),
+      expect.objectContaining({
+        id: 'call_stock',
+        name: 'stock',
+        args: { ticker: 'CH' },
+      }),
+    ]);
+  });
+
+  it('does not seal a streamed tool when the same chunk also carries its own index', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [{ name: 'weather' }, { name: 'stock' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              args: '',
+              index: 0,
+            },
+            {
+              id: 'call_stock',
+              name: 'stock',
+              args: '{"ticker":"C',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(0);
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              args: 'H"}',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
+      id: 'call_weather',
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+  });
+
+  it('preserves same-tool turns across per-call streamed eager starts', async () => {
+    const graph = createGraph();
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.args.city}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather_1',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather_2',
+              name: 'weather',
+              args: '{"city":"B',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
+      id: 'call_weather_1',
+      name: 'weather',
+      args: { city: 'NYC' },
+      turn: 0,
+    });
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              args: 'oston"}',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_weather_1',
+              name: 'weather',
+              args: { city: 'NYC' },
+            },
+            {
+              id: 'call_weather_2',
+              name: 'weather',
+              args: { city: 'Boston' },
+            },
+          ],
+          response_metadata: finalToolCallResponseMetadata,
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(2);
+    expect(toolExecuteCalls[1].toolCalls[0]).toMatchObject({
+      id: 'call_weather_2',
+      name: 'weather',
+      args: { city: 'Boston' },
+      turn: 1,
+    });
+    expect(graph.eagerEventToolUsageCount.get('weather')).toBe(2);
+  });
+
+  it('scopes streamed chunk accumulation by step key', async () => {
+    const graph = createGraph({
+      getStepKey: jest.fn((metadata?: Record<string, unknown>) =>
+        String(metadata?.langgraph_node ?? 'step-key')
+      ),
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_agent_a',
+              name: 'weather',
+              args: '{"city":"N',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent_a' },
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_agent_b',
+              name: 'weather',
+              args: '{"city":"S',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent_b' },
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              args: 'F"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent_b' },
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(0);
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              args: 'YC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent_a' },
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(0);
+    expect(
+      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_a', 0))?.argsText
+    ).toBe('{"city":"NYC"}');
+    expect(
+      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_b', 0))?.argsText
+    ).toBe('{"city":"SF"}');
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_agent_b',
+              name: 'weather',
+              args: { city: 'SF' },
             },
           ],
+          response_metadata: finalToolCallResponseMetadata,
         } as unknown as t.StreamChunk,
       },
       { langgraph_node: 'agent_b' },
       graph
     );
 
+    expect(
+      graph.eagerEventToolCallChunks.has(chunkStateKey('agent_b', 0))
+    ).toBe(false);
+    expect(
+      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_a', 0))?.argsText
+    ).toBe('{"city":"NYC"}');
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_agent_a',
+              name: 'weather',
+              args: { city: 'NYC' },
+            },
+          ],
+          response_metadata: finalToolCallResponseMetadata,
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent_a' },
+      graph
+    );
+
+    expect(toolExecuteCalls).toHaveLength(2);
+    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
+      id: 'call_agent_b',
+      name: 'weather',
+      args: { city: 'SF' },
+    });
+    expect(toolExecuteCalls[1].toolCalls[0]).toMatchObject({
+      id: 'call_agent_a',
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+    expect(graph.eagerEventToolCallChunks.size).toBe(0);
+  });
+
+  it('does not prestart when batch-sensitive hooks are configured', async () => {
+    const graph = createGraph({
+      hookRegistry: {} as StandardGraph['hookRegistry'],
+    });
+    const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+
+    await new ChatModelStreamHandler().handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: { city: 'NYC' },
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent' },
+      graph
+    );
+
+    expect(dispatchSpy).not.toHaveBeenCalledWith(
+      GraphEvents.ON_TOOL_EXECUTE,
+      expect.anything(),
+      expect.anything()
+    );
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
+  });
+
+  it('does not buffer streamed chunks when eager execution is disabled', async () => {
+    const graph = createGraph({
+      eagerEventToolExecution: { enabled: false },
+    } as Partial<StandardGraph>);
+    const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+
+    await new ChatModelStreamHandler().handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent' },
+      graph
+    );
+
+    expect(dispatchSpy).not.toHaveBeenCalledWith(
+      GraphEvents.ON_TOOL_EXECUTE,
+      expect.anything(),
+      expect.anything()
+    );
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
+    expect(graph.eagerEventToolCallChunks.size).toBe(0);
+  });
+
+  it('does not prestart local-engine direct coding tools', async () => {
+    const graph = createGraph({
+      toolExecution: {
+        engine: 'local',
+      } as StandardGraph['toolExecution'],
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.OPENAI,
+          reasoningKey: 'reasoning_content',
+          toolDefinitions: [{ name: Constants.EXECUTE_CODE }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+
+    await new ChatModelStreamHandler().handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_code',
+              name: Constants.EXECUTE_CODE,
+              args: { code: 'print(1)' },
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      { langgraph_node: 'agent' },
+      graph
+    );
+
+    expect(dispatchSpy).not.toHaveBeenCalledWith(
+      GraphEvents.ON_TOOL_EXECUTE,
+      expect.anything(),
+      expect.anything()
+    );
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
+    expect(graph.eagerEventToolCallChunks.size).toBe(0);
+  });
+
+  it('does not prestart streamed local-engine direct coding tools', async () => {
+    const graph = createGraph({
+      toolExecution: {
+        engine: 'local',
+      } as StandardGraph['toolExecution'],
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.OPENAI,
+          reasoningKey: 'reasoning_content',
+          toolDefinitions: [
+            { name: Constants.EXECUTE_CODE },
+            { name: 'weather' },
+          ],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'call_code',
+              name: Constants.EXECUTE_CODE,
+              args: '{"code":"print(1)"}',
+              index: 1,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchSpy).not.toHaveBeenCalledWith(
+      GraphEvents.ON_TOOL_EXECUTE,
+      expect.anything(),
+      expect.anything()
+    );
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
+    expect(graph.eagerEventToolCallChunks.size).toBe(0);
+  });
+
+  it('prestarts streamed remote bash tools when the next Anthropic tool call begins', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: Constants.READ_FILE },
+          ],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
@@ -2086,13 +2890,15 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              args: 'F"}',
-              index: 0,
+              id: 'toolu_env',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo env"}',
+              index: 2,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent_b' },
+      metadata,
       graph
     );
 
@@ -2105,135 +2911,256 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              args: 'YC"}',
-              index: 0,
+              id: 'toolu_net',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo net"}',
+              index: 3,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent_a' },
+      metadata,
       graph
     );
 
-    expect(toolExecuteCalls).toHaveLength(0);
-    expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_a', 0))?.argsText
-    ).toBe('{"city":"NYC"}');
-    expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_b', 0))?.argsText
-    ).toBe('{"city":"SF"}');
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls).toEqual([
+      expect.objectContaining({
+        id: 'toolu_env',
+        name: Constants.BASH_TOOL,
+        args: { command: 'echo env' },
+        stepId: expect.stringMatching(/^step_/),
+        turn: 0,
+      }),
+    ]);
+    expect(graph.eagerEventToolExecutions.has('toolu_env')).toBe(true);
+    expect(graph.eagerEventToolExecutions.has('toolu_net')).toBe(false);
+  });
+
+  it('does not prestart streamed remote tools when graph tools may appear later', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: Constants.READ_FILE },
+          ],
+          graphTools: [
+            { name: 'transfer_to_researcher' } as unknown as t.GenericTool,
+          ],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
+
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
 
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
         chunk: {
           content: '',
-          tool_calls: [
+          tool_call_chunks: [
             {
-              id: 'call_agent_b',
-              name: 'weather',
-              args: { city: 'SF' },
+              id: 'toolu_env',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo env"}',
+              index: 2,
             },
           ],
-          response_metadata: finalToolCallResponseMetadata,
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent_b' },
+      metadata,
       graph
     );
 
-    expect(graph.eagerEventToolCallChunks.has(chunkStateKey('agent_b', 0))).toBe(
-      false
-    );
-    expect(
-      graph.eagerEventToolCallChunks.get(chunkStateKey('agent_a', 0))?.argsText
-    ).toBe('{"city":"NYC"}');
-
     await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
         chunk: {
           content: '',
-          tool_calls: [
+          tool_call_chunks: [
             {
-              id: 'call_agent_a',
-              name: 'weather',
-              args: { city: 'NYC' },
+              id: 'toolu_net',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo net"}',
+              index: 3,
             },
           ],
-          response_metadata: finalToolCallResponseMetadata,
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent_a' },
+      metadata,
       graph
     );
 
-    expect(toolExecuteCalls).toHaveLength(2);
-    expect(toolExecuteCalls[0].toolCalls[0]).toMatchObject({
-      id: 'call_agent_b',
-      name: 'weather',
-      args: { city: 'SF' },
-    });
-    expect(toolExecuteCalls[1].toolCalls[0]).toMatchObject({
-      id: 'call_agent_a',
-      name: 'weather',
-      args: { city: 'NYC' },
-    });
+    expect(toolExecuteCalls).toHaveLength(0);
+    expect(graph.eagerEventToolExecutions.size).toBe(0);
     expect(graph.eagerEventToolCallChunks.size).toBe(0);
   });
 
-  it('does not prestart when batch-sensitive hooks are configured', async () => {
-    const graph = createGraph({ hookRegistry: {} as StandardGraph['hookRegistry'] });
-    const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+  it('prestarts streamed remote bash tools when code output references are enabled', async () => {
+    const graph = createGraph({
+      toolOutputReferences: { enabled: true },
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: Constants.READ_FILE },
+          ],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
+        if (event !== GraphEvents.ON_TOOL_EXECUTE) {
+          return;
+        }
+        const batch = data as t.ToolExecuteBatchRequest;
+        toolExecuteCalls.push(batch);
+        batch.resolve(
+          batch.toolCalls.map((call) => ({
+            toolCallId: call.id,
+            status: 'success',
+            content: `ok ${call.name}`,
+          }))
+        );
+      });
 
-    await new ChatModelStreamHandler().handle(
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    for (const args of ['{"command":"echo ', 'env && ', 'pwd"}']) {
+      await handler.handle(
+        GraphEvents.CHAT_MODEL_STREAM,
+        {
+          chunk: {
+            content: '',
+            tool_call_chunks: [
+              {
+                id: 'toolu_env',
+                name: Constants.BASH_TOOL,
+                args,
+                index: 2,
+              },
+            ],
+          } as unknown as t.StreamChunk,
+        },
+        metadata,
+        graph
+      );
+    }
+
+    expect(toolExecuteCalls).toHaveLength(0);
+
+    await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
         chunk: {
           content: '',
-          tool_calls: [
+          tool_call_chunks: [
             {
-              id: 'call_weather',
-              name: 'weather',
-              args: { city: 'NYC' },
+              id: 'toolu_net',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo net"}',
+              index: 3,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent' },
+      metadata,
       graph
     );
 
-    expect(dispatchSpy).not.toHaveBeenCalledWith(
-      GraphEvents.ON_TOOL_EXECUTE,
-      expect.anything(),
-      expect.anything()
-    );
-    expect(graph.eagerEventToolExecutions.size).toBe(0);
+    expect(toolExecuteCalls).toHaveLength(1);
+    expect(toolExecuteCalls[0].toolCalls).toEqual([
+      expect.objectContaining({
+        id: 'toolu_env',
+        name: Constants.BASH_TOOL,
+        args: { command: 'echo env && pwd' },
+      }),
+    ]);
   });
 
-  it('does not buffer streamed chunks when eager execution is disabled', async () => {
+  it('does not prestart streamed code tools whose args contain output references', async () => {
     const graph = createGraph({
-      eagerEventToolExecution: { enabled: false },
-    } as Partial<StandardGraph>);
+      toolOutputReferences: { enabled: true },
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: Constants.READ_FILE },
+          ],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
     const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
 
-    await new ChatModelStreamHandler().handle(
+    await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
         chunk: {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_weather',
-              name: 'weather',
-              args: '{"city":"NYC"}',
-              index: 0,
+              id: 'toolu_ref',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"cat <<EOF\\n{{tool0turn0}}\\nEOF"}',
+              index: 2,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent' },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'toolu_next',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo next"}',
+              index: 3,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
       graph
     );
 
@@ -2242,42 +3169,63 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       expect.anything(),
       expect.anything()
     );
-    expect(graph.eagerEventToolExecutions.size).toBe(0);
-    expect(graph.eagerEventToolCallChunks.size).toBe(0);
   });
 
-  it('does not prestart local-engine direct coding tools', async () => {
+  it('does not prestart streamed tools when the next Anthropic tool call is a graph tool', async () => {
+    const handoffToolName = `${Constants.LC_TRANSFER_TO_}researcher`;
     const graph = createGraph({
-      toolExecution: {
-        engine: 'local',
-      } as StandardGraph['toolExecution'],
       getAgentContext: jest.fn(
         (): Partial<AgentContext> => ({
-          provider: Providers.OPENAI,
-          reasoningKey: 'reasoning_content',
-          toolDefinitions: [{ name: Constants.EXECUTE_CODE }],
-          graphTools: [],
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: handoffToolName },
+          ],
+          graphTools: [{ name: handoffToolName } as unknown as t.GenericTool],
           agentId: 'agent_1',
         })
       ) as unknown as StandardGraph['getAgentContext'],
     });
     const dispatchSpy = jest.spyOn(events, 'safeDispatchCustomEvent');
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
 
-    await new ChatModelStreamHandler().handle(
+    await handler.handle(
       GraphEvents.CHAT_MODEL_STREAM,
       {
         chunk: {
           content: '',
-          tool_calls: [
+          tool_call_chunks: [
             {
-              id: 'call_code',
-              name: Constants.EXECUTE_CODE,
-              args: { code: 'print(1)' },
+              id: 'toolu_env',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo env"}',
+              index: 2,
             },
           ],
         } as unknown as t.StreamChunk,
       },
-      { langgraph_node: 'agent' },
+      metadata,
+      graph
+    );
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'toolu_handoff',
+              name: handoffToolName,
+              args: '{"message":"check this"}',
+              index: 3,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
       graph
     );
 
@@ -2287,20 +3235,20 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       expect.anything()
     );
     expect(graph.eagerEventToolExecutions.size).toBe(0);
-    expect(graph.eagerEventToolCallChunks.size).toBe(0);
   });
 
-  it('does not prestart streamed local-engine direct coding tools', async () => {
+  it('does not prestart streamed tools after a graph tool appeared earlier in the same step', async () => {
+    const handoffToolName = `${Constants.LC_TRANSFER_TO_}researcher`;
     const graph = createGraph({
-      toolExecution: {
-        engine: 'local',
-      } as StandardGraph['toolExecution'],
       getAgentContext: jest.fn(
         (): Partial<AgentContext> => ({
-          provider: Providers.OPENAI,
-          reasoningKey: 'reasoning_content',
-          toolDefinitions: [{ name: Constants.EXECUTE_CODE }, { name: 'weather' }],
-          graphTools: [],
+          provider: Providers.ANTHROPIC,
+          reasoningKey: 'reasoning',
+          toolDefinitions: [
+            { name: Constants.BASH_TOOL },
+            { name: handoffToolName },
+          ],
+          graphTools: [{ name: handoffToolName } as unknown as t.GenericTool],
           agentId: 'agent_1',
         })
       ) as unknown as StandardGraph['getAgentContext'],
@@ -2316,10 +3264,10 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_weather',
-              name: 'weather',
-              args: '{"city":"NYC"}',
-              index: 0,
+              id: 'toolu_env',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo env"}',
+              index: 2,
             },
           ],
         } as unknown as t.StreamChunk,
@@ -2334,10 +3282,28 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
           content: '',
           tool_call_chunks: [
             {
-              id: 'call_code',
-              name: Constants.EXECUTE_CODE,
-              args: '{"code":"print(1)"}',
-              index: 1,
+              id: 'toolu_handoff',
+              name: handoffToolName,
+              args: '{"message":"partial',
+              index: 3,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: '',
+          tool_call_chunks: [
+            {
+              id: 'toolu_next',
+              name: Constants.BASH_TOOL,
+              args: '{"command":"echo next"}',
+              index: 4,
             },
           ],
         } as unknown as t.StreamChunk,
@@ -2352,7 +3318,6 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
       expect.anything()
     );
     expect(graph.eagerEventToolExecutions.size).toBe(0);
-    expect(graph.eagerEventToolCallChunks.size).toBe(0);
   });
 
   it('does not prestart event tools in a mixed direct-tool batch', async () => {
@@ -2411,8 +3376,9 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     const graph = createGraph();
     graph.eagerEventToolUsageCount.set('weather', 1);
     const toolExecuteCalls: t.ToolExecuteBatchRequest[] = [];
-    jest.spyOn(events, 'safeDispatchCustomEvent').mockImplementation(
-      async (event, data): Promise<void> => {
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data): Promise<void> => {
         if (event !== GraphEvents.ON_TOOL_EXECUTE) {
           return;
         }
@@ -2425,8 +3391,7 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
             content: 'sunny',
           },
         ]);
-      }
-    );
+      });
 
     await new ChatModelStreamHandler().handle(
       GraphEvents.CHAT_MODEL_STREAM,