@librechat/agents 3.2.32 → 3.2.34

package/src/llm/openai/sequentialToolCallSeals.test.ts

@@ -0,0 +1,199 @@
+import { AIMessageChunk } from '@langchain/core/messages';
+import { expect, test, describe, beforeEach, afterAll } from '@jest/globals';
+import type { BaseMessageChunk } from '@langchain/core/messages';
+import {
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { ChatOpenAI, AzureChatOpenAI } from './index';
+
+type DeltaConverter = {
+  _convertCompletionsDeltaToBaseMessageChunk(
+    delta: Record<string, unknown>,
+    rawResponse: Record<string, unknown>
+  ): BaseMessageChunk;
+};
+
+const rawResponse = {
+  id: 'chatcmpl-1',
+  object: 'chat.completion.chunk',
+  created: 1,
+  model: 'gpt-5.5',
+  choices: [],
+};
+
+const toolCallDelta = {
+  role: 'assistant',
+  tool_calls: [
+    {
+      index: 0,
+      id: 'call_1',
+      type: 'function',
+      function: { name: 'weather', arguments: '{"ci' },
+    },
+  ],
+};
+
+function convertDelta(
+  model: unknown,
+  delta: Record<string, unknown>
+): AIMessageChunk {
+  const converter = (model as { completions: DeltaConverter }).completions;
+  const message = converter._convertCompletionsDeltaToBaseMessageChunk(
+    delta,
+    rawResponse
+  );
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+function adapterOf(message: AIMessageChunk): unknown {
+  return (message.response_metadata as Record<string, unknown>)[
+    STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
+  ];
+}
+
+describe('Chat Completions sequential tool-call seal stamping', () => {
+  // Both the implementation (OPENAI_BASE_URL fallback) and the Azure
+  // constructor (AZURE_OPENAI_BASE_PATH fallback) read the environment, so
+  // isolate these vars to keep the suite deterministic across shells.
+  const ISOLATED_ENV_VARS = ['OPENAI_BASE_URL', 'AZURE_OPENAI_BASE_PATH'];
+  const originalEnv = new Map(
+    ISOLATED_ENV_VARS.map((name) => [name, process.env[name]])
+  );
+
+  beforeEach(() => {
+    for (const name of ISOLATED_ENV_VARS) {
+      delete process.env[name];
+    }
+  });
+
+  afterAll(() => {
+    for (const [name, value] of originalEnv) {
+      if (value == null) {
+        delete process.env[name];
+      } else {
+        process.env[name] = value;
+      }
+    }
+  });
+
+  test('stamps tool-call deltas when no baseURL is configured (official)', () => {
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps tool-call deltas for an explicit api.openai.com baseURL', () => {
+    const model = new ChatOpenAI({
+      model: 'gpt-5.5',
+      apiKey: 'test',
+      configuration: { baseURL: 'https://api.openai.com/v1' },
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('does not stamp tool-call deltas for OpenAI-compatible endpoints', () => {
+    const model = new ChatOpenAI({
+      model: 'kimi-k2',
+      apiKey: 'test',
+      configuration: { baseURL: 'https://api.moonshot.ai/v1' },
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp text-only deltas', () => {
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, {
+      role: 'assistant',
+      content: 'hello',
+    });
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp when OPENAI_BASE_URL routes to a compatible endpoint', () => {
+    process.env.OPENAI_BASE_URL = 'https://api.moonshot.ai/v1';
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('stamps when OPENAI_BASE_URL points at api.openai.com', () => {
+    process.env.OPENAI_BASE_URL = 'https://api.openai.com/v1';
+    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure OpenAI tool-call deltas (first-party endpoint)', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiInstanceName: 'test-instance',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure deltas for an *.openai.azure.com base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath:
+        'https://test-resource.openai.azure.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('stamps Azure deltas for a regional cognitive services base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath:
+        'https://westeurope.api.cognitive.microsoft.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBe(
+      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+    );
+  });
+
+  test('does not stamp Azure deltas routed through a proxy base path', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      azureOpenAIBasePath: 'https://proxy.example.com/openai/deployments',
+    });
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+
+  test('does not stamp Azure deltas with a custom client baseURL', () => {
+    const model = new AzureChatOpenAI({
+      azureOpenAIApiKey: 'test',
+      azureOpenAIApiInstanceName: 'test-instance',
+      azureOpenAIApiDeploymentName: 'test-deployment',
+      azureOpenAIApiVersion: '2024-08-01-preview',
+      configuration: { baseURL: 'https://gateway.example.com/azure' },
+    } as unknown as ConstructorParameters<typeof AzureChatOpenAI>[0]);
+    const message = convertDelta(model, toolCallDelta);
+    expect(adapterOf(message)).toBeUndefined();
+  });
+});

package/src/llm/vertexai/index.ts

@@ -11,6 +11,11 @@ import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 
 /**
  * `@langchain/google-common`'s `_streamResponseChunks` emits usage on TWO
@@ -48,6 +53,31 @@ export function repairStreamUsageMetadata(
   return generationInfoUsage;
 }
 
+/**
+ * The Gemini API delivers function calls as complete objects — never as
+ * partial arg deltas. `@langchain/google-common` pre-parses each streamed
+ * functionCall part into `tool_calls` (invalid args land in
+ * `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed
+ * cleanly is sealed on arrival for eager tool execution. Anything that fails
+ * the parse check is left unstamped and falls back to the lazy path.
+ */
+export function sealCompleteStreamedToolCalls(message: AIMessageChunk): void {
+  const chunkCount = message.tool_call_chunks?.length ?? 0;
+  if (
+    chunkCount === 0 ||
+    (message.invalid_tool_calls?.length ?? 0) > 0 ||
+    (message.tool_calls?.length ?? 0) !== chunkCount
+  ) {
+    return;
+  }
+  message.response_metadata = {
+    ...message.response_metadata,
+    [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+      GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+    [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+  };
+}
+
 type AdditionalKwargs =
   | undefined
   | (BaseMessage['additional_kwargs'] & {
@@ -503,6 +533,7 @@ export class ChatVertexAI extends ChatGoogle {
         if (repaired !== chunk.message.usage_metadata) {
           chunk.message.usage_metadata = repaired;
         }
+        sealCompleteStreamedToolCalls(chunk.message);
       }
       yield chunk;
     }

package/src/llm/vertexai/sealStreamedToolCalls.test.ts

@@ -0,0 +1,88 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { sealCompleteStreamedToolCalls } from './index';
+
+describe('sealCompleteStreamedToolCalls', () => {
+  test('stamps an on-arrival seal when every tool-call chunk parsed cleanly', () => {
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          id: 'call_1',
+          name: 'weather',
+          args: '{"city":"NYC"}',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(message.response_metadata).toMatchObject({
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+      [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+    });
+  });
+
+  test('stamps multi-call chunks when all calls are complete', () => {
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          id: 'call_1',
+          name: 'weather',
+          args: '{"city":"NYC"}',
+          type: 'tool_call_chunk',
+        },
+        {
+          id: 'call_2',
+          name: 'stock',
+          args: '{"ticker":"CH"}',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+  });
+
+  test('leaves chunks without tool calls unstamped', () => {
+    const message = new AIMessageChunk({ content: 'hello' });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+
+  test('leaves chunks with unparsable tool calls unstamped', () => {
+    // No id forces the parse into invalid_tool_calls.
+    const message = new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          name: 'weather',
+          args: '{"city":',
+          type: 'tool_call_chunk',
+        },
+      ],
+    });
+
+    sealCompleteStreamedToolCalls(message);
+
+    expect(
+      message.response_metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+});

package/src/llm/vertexai/streamSealDispatch.test.ts

@@ -0,0 +1,148 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { HumanMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { ChatVertexAI } from './index';
+
+/**
+ * Registered stream handlers consume chunks through `handleLLMNewToken`
+ * callback events. `@langchain/google-common` yields each chunk BEFORE
+ * dispatching that callback, and the generator only resumes (firing the
+ * callback) after this package's `_streamResponseChunks` override has
+ * stamped the seal on the same message object — so callback consumers must
+ * observe sealed chunks. This drives the real google-common stream loop and
+ * conversion with a stubbed connection to lock that ordering in.
+ */
+describe('Vertex stream seal dispatch', () => {
+  async function runStream(outputs: unknown[]): Promise<{
+    yielded: AIMessageChunk[];
+    dispatched: AIMessageChunk[];
+  }> {
+    const model = new ChatVertexAI({
+      model: 'gemini-2.5-flash',
+      authOptions: {
+        projectId: 'test-project',
+        credentials: { client_email: 'test@test', private_key: 'test' },
+      },
+    });
+
+    let index = 0;
+    const fakeStream = {
+      get streamDone(): boolean {
+        return index > outputs.length;
+      },
+      async nextChunk(): Promise<unknown> {
+        const output = index < outputs.length ? outputs[index] : null;
+        index += 1;
+        return output;
+      },
+    };
+    (
+      model as unknown as {
+        streamedConnection: { request: unknown };
+      }
+    ).streamedConnection.request = jest.fn(async () => ({ data: fakeStream }));
+
+    const dispatched: AIMessageChunk[] = [];
+    const runManager = {
+      handleCustomEvent: jest.fn(async () => undefined),
+      handleLLMNewToken: jest.fn(
+        async (
+          _token: string,
+          _idx?: unknown,
+          _runId?: unknown,
+          _parentRunId?: unknown,
+          _tags?: unknown,
+          fields?: { chunk?: ChatGenerationChunk }
+        ) => {
+          const message = fields?.chunk?.message;
+          if (message instanceof AIMessageChunk) {
+            dispatched.push(message);
+          }
+        }
+      ),
+    } as unknown as CallbackManagerForLLMRun;
+
+    const yielded: AIMessageChunk[] = [];
+    for await (const chunk of model._streamResponseChunks(
+      [new HumanMessage('hi')],
+      {} as Parameters<ChatVertexAI['_streamResponseChunks']>[1],
+      runManager
+    )) {
+      if (chunk.message instanceof AIMessageChunk) {
+        yielded.push(chunk.message);
+      }
+    }
+    return { yielded, dispatched };
+  }
+
+  test('callback consumers receive function-call chunks already sealed', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        candidates: [
+          {
+            content: {
+              role: 'model',
+              parts: [
+                { functionCall: { name: 'weather', args: { city: 'NYC' } } },
+              ],
+            },
+            index: 0,
+          },
+        ],
+      },
+    ]);
+
+    const metadataOf = (m: AIMessageChunk): Record<string, unknown> =>
+      m.response_metadata as Record<string, unknown>;
+
+    const yieldedCall = yielded.find(
+      (m) => (m.tool_call_chunks?.length ?? 0) > 0
+    );
+    expect(yieldedCall).toBeDefined();
+    expect(
+      metadataOf(yieldedCall!)[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+
+    const dispatchedCall = dispatched.find(
+      (m) => (m.tool_call_chunks?.length ?? 0) > 0
+    );
+    expect(dispatchedCall).toBeDefined();
+    expect(dispatchedCall!.tool_calls?.[0]).toMatchObject({
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+    expect(
+      metadataOf(dispatchedCall!)[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]
+    ).toEqual({ kind: 'all' });
+    expect(
+      metadataOf(dispatchedCall!)[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBe(GOOGLE_STREAMED_TOOL_CALL_ADAPTER);
+  });
+
+  test('text-only chunks are not sealed on either path', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        candidates: [
+          {
+            content: { role: 'model', parts: [{ text: 'hello' }] },
+            index: 0,
+          },
+        ],
+      },
+    ]);
+
+    const hasSeal = (m: AIMessageChunk): boolean =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ] != null;
+
+    expect(yielded.some(hasSeal)).toBe(false);
+    expect(dispatched.some(hasSeal)).toBe(false);
+  });
+});

package/src/stream.ts

@@ -5,6 +5,12 @@ import type { AIMessageChunk } from '@langchain/core/messages';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
+import {
+  getStreamedToolCallSeal,
+  getStreamedToolCallAdapter,
+  streamedToolCallAdapterAllowsSequentialSeal,
+  type StreamedToolCallSeal,
+} from '@/tools/streamedToolCallSeals';
 import {
   ToolCallTypes,
   ContentTypes,
@@ -15,11 +21,6 @@ import {
   CODE_EXECUTION_TOOLS,
   LOCAL_CODING_BUNDLE_NAMES,
 } from '@/common';
-import {
-  getStreamedToolCallSeal,
-  getStreamedToolCallAdapter,
-  type StreamedToolCallSeal,
-} from '@/tools/streamedToolCallSeals';
 import {
   buildToolExecutionRequestPlan,
   coerceRecordArgs,
@@ -265,6 +266,21 @@ function hasExplicitStreamedToolCallSeals(
   );
 }
 
+/**
+ * True when a provider adapter marked every tool call on this chunk as
+ * complete on arrival (seal kind `all`), e.g. Google GenAI / Vertex AI, whose
+ * protocol delivers function calls as whole objects rather than arg deltas.
+ */
+function hasOnArrivalToolCallSeal(chunk: Partial<AIMessageChunk>): boolean {
+  const metadata = chunk.response_metadata as
+    | Record<string, unknown>
+    | undefined;
+  return (
+    getStreamedToolCallAdapter(metadata) != null &&
+    getStreamedToolCallSeal(metadata)?.kind === 'all'
+  );
+}
+
 function hasDirectToolCallInBatch(args: {
   graph: StandardGraph;
   agentContext?: AgentContext;
@@ -1405,6 +1421,21 @@ export class ChatModelStreamHandler implements t.EventHandler {
         if (!hasToolCallChunks) {
           pruneEagerToolCallChunkStates({ graph, stepKey, clearStep: true });
         }
+      } else if (
+        hasOnArrivalToolCallSeal(chunk) &&
+        !hasPotentialDirectToolInStreamContext({ graph, agentContext })
+      ) {
+        // Providers like Google never signal `tool_calls`/`tool_use` as the
+        // finish reason, but their adapters seal calls on arrival — prestart
+        // these mid-stream under the same direct-tool guard as streamed
+        // chunk sealing.
+        startEagerToolExecutions({
+          graph,
+          metadata,
+          agentContext,
+          toolCalls: chunk.tool_calls,
+          skipExisting: true,
+        });
       }
     }
 
@@ -1435,7 +1466,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
         chunk.response_metadata as Record<string, unknown> | undefined
       );
       const allowSequentialSeal =
-        canPrestartSequentialStreamedToolChunks(agentContext);
+        canPrestartSequentialStreamedToolChunks(agentContext) ||
+        streamedToolCallAdapterAllowsSequentialSeal(
+          chunk.response_metadata as Record<string, unknown> | undefined
+        );
       const canStreamEager =
         (allowSequentialSeal || hasExplicitStreamedToolCallSeals(chunk)) &&
         !hasPotentialDirectToolInStreamContext({ graph, agentContext }) &&

package/src/tools/ToolNode.ts

@@ -2476,6 +2476,49 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         }
       }
 
+      /**
+       * Per-call completion fast-path: when the host reports a result
+       * through `onResult` before the batch resolves, emit that call's
+       * completed run step immediately instead of waiting for the slowest
+       * call in the batch. Safe only when nothing can change the result
+       * after execution — post-tool hooks may rewrite output and HITL may
+       * deny a call, so those configurations keep batch-time emission.
+       * Ids are claimed synchronously before the async dispatch and
+       * released if the dispatch fails, letting the batch path re-emit.
+       */
+      const canEmitEarlyCompletions =
+        this.hookRegistry == null && this.humanInTheLoop?.enabled !== true;
+      const earlyCompletionDispatchedIds = new Set<string>();
+      const earlyCompletionDispatches: Array<Promise<void>> = [];
+      const dispatchRequestById = new Map(
+        dispatchRequests.map((request) => [request.id, request])
+      );
+      const onResult = (result: t.ToolExecuteResult): void => {
+        const request =
+          result.toolCallId != null
+            ? dispatchRequestById.get(result.toolCallId)
+            : undefined;
+        if (
+          request == null ||
+          earlyCompletionDispatchedIds.has(result.toolCallId)
+        ) {
+          return;
+        }
+        earlyCompletionDispatchedIds.add(result.toolCallId);
+        earlyCompletionDispatches.push(
+          this.dispatchEarlyToolCompletion(result, request, config).then(
+            (dispatched) => {
+              if (!dispatched) {
+                earlyCompletionDispatchedIds.delete(result.toolCallId);
+              }
+            },
+            () => {
+              earlyCompletionDispatchedIds.delete(result.toolCallId);
+            }
+          )
+        );
+      };
+
       const dispatchPromise =
         dispatchRequests.length === 0
           ? Promise.resolve([] as t.ToolExecuteResult[])
@@ -2506,6 +2549,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
                 maybeResolve();
               },
               reject,
+              ...(canEmitEarlyCompletions && { onResult }),
             };
 
             void safeDispatchCustomEvent(
@@ -2540,6 +2584,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         eagerResultsPromise,
         dispatchPromise,
       ]);
+      // Settle in-flight early completion dispatches before the batch loop
+      // below decides which completions still need emitting.
+      await Promise.allSettled(earlyCompletionDispatches);
       const eagerCompletionDispatchedIds = new Set(
         eagerResults
           .filter((result) => result.completionDispatched)
@@ -2728,7 +2775,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           });
         }
 
-        if (!eagerCompletionDispatchedIds.has(result.toolCallId)) {
+        if (
+          !eagerCompletionDispatchedIds.has(result.toolCallId) &&
+          !earlyCompletionDispatchedIds.has(result.toolCallId)
+        ) {
           await this.dispatchStepCompleted(
             result.toolCallId,
             toolName,
@@ -2946,7 +2996,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     output: string,
     config: RunnableConfig,
     turn?: number
-  ): Promise<void> {
+  ): Promise<boolean> {
     const stepId = this.toolCallStepIds?.get(toolCallId) ?? '';
     if (!stepId) {
       // eslint-disable-next-line no-console
@@ -2957,7 +3007,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       );
     }
 
-    await safeDispatchCustomEvent(
+    const dispatched = await safeDispatchCustomEvent(
       GraphEvents.ON_RUN_STEP_COMPLETED,
       {
         result: {
@@ -2975,6 +3025,38 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       },
       config
     );
+    return dispatched !== false;
+  }
+
+  /**
+   * Emits the completed run step for a single host-reported result before
+   * the batch resolves. Mirrors the batch loop's output formatting exactly;
+   * callers gate on the no-hooks/no-HITL configuration, so the raw result
+   * content here is also the final content. Returns whether the event was
+   * actually dispatched so the caller can fall back to batch-time emission.
+   */
+  private async dispatchEarlyToolCompletion(
+    result: t.ToolExecuteResult,
+    request: t.ToolCallRequest,
+    config: RunnableConfig
+  ): Promise<boolean> {
+    const output =
+      result.status === 'error'
+        ? `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`
+        : truncateToolResultContent(
+          typeof result.content === 'string'
+            ? result.content
+            : JSON.stringify(result.content),
+          this.maxToolResultChars
+        );
+    return this.dispatchStepCompleted(
+      result.toolCallId,
+      request.name,
+      request.args,
+      output,
+      config,
+      request.turn
+    );
   }
 
   /**