@librechat/agents 3.1.45 → 3.1.51

package/src/specs/azure.simple.test.ts

@@ -16,8 +16,8 @@ import {
   createMetadataAggregator,
 } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { Run } from '@/run';
 
@@ -83,7 +83,6 @@ describeIfAzure(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   > => ({
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/cache.simple.test.ts

@@ -10,9 +10,9 @@ import {
   UsageMetadata,
 } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { ModelEndHandler, ToolEndHandler } from '@/events';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { GraphEvents, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
@@ -36,7 +36,6 @@ describe('Prompt Caching Integration Tests', () => {
     const customHandlers: Record<string | GraphEvents, t.EventHandler> = {
       [GraphEvents.TOOL_END]: new ToolEndHandler(),
       [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-      [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
       [GraphEvents.ON_RUN_STEP_COMPLETED]: {
         handle: (
           event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/custom-event-await.test.ts

@@ -1,8 +1,8 @@
 import { HumanMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { createContentAggregator } from '@/stream';
 import { Run } from '@/run';
 
 describe('Custom event handler awaitHandlers behavior', () => {
@@ -39,7 +39,6 @@ describe('Custom event handler awaitHandlers behavior', () => {
     const customHandlers: Record<string | GraphEvents, t.EventHandler> = {
       [GraphEvents.TOOL_END]: new ToolEndHandler(),
       [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-      [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
       [GraphEvents.ON_RUN_STEP_COMPLETED]: {
         handle: (
           event: GraphEvents.ON_RUN_STEP_COMPLETED,
@@ -133,7 +132,6 @@ describe('Custom event handler awaitHandlers behavior', () => {
     const customHandlers: Record<string | GraphEvents, t.EventHandler> = {
       [GraphEvents.TOOL_END]: new ToolEndHandler(),
       [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-      [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
       [GraphEvents.ON_RUN_STEP_COMPLETED]: {
         handle: (
           event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/deepseek.simple.test.ts

@@ -11,8 +11,8 @@ import {
 import type * as t from '@/types';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { Run } from '@/run';
 
@@ -64,7 +64,6 @@ const skipTests = process.env.DEEPSEEK_API_KEY == null;
     > => ({
       [GraphEvents.TOOL_END]: new ToolEndHandler(),
       [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-      [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
       [GraphEvents.ON_RUN_STEP_COMPLETED]: {
         handle: (
           event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/moonshot.simple.test.ts

@@ -11,8 +11,8 @@ import {
 import type * as t from '@/types';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { Run } from '@/run';
 
 const provider = Providers.MOONSHOT;
@@ -71,7 +71,6 @@ const skipTests = process.env.MOONSHOT_API_KEY == null;
     > => ({
       [GraphEvents.TOOL_END]: new ToolEndHandler(),
       [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-      [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
       [GraphEvents.ON_RUN_STEP_COMPLETED]: {
         handle: (
           event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/openai.simple.test.ts

@@ -16,8 +16,8 @@ import {
   createMetadataAggregator,
 } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
@@ -63,7 +63,6 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   > => ({
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/openrouter.simple.test.ts

@@ -9,8 +9,8 @@ import {
 import type * as t from '@/types';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
@@ -54,7 +54,6 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   > => ({
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
   });
 
   test(`${capitalizeFirstLetter(provider)}: simple stream + title`, async () => {

package/src/specs/reasoning.test.ts

@@ -10,8 +10,8 @@ import {
 } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
+import { createContentAggregator } from '@/stream';
 import { GraphEvents, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
@@ -97,7 +97,6 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     string | GraphEvents,
     t.EventHandler
   > => ({
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/specs/tool-error.test.ts

@@ -5,8 +5,8 @@ import { ToolCall } from '@langchain/core/messages/tool';
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { createContentAggregator } from '@/stream';
 import { GraphEvents, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
@@ -83,7 +83,6 @@ describe('Tool Error Handling Tests', () => {
   > => ({
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,

package/src/tools/ToolNode.ts

@@ -39,6 +39,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   toolCallStepIds?: Map<string, string>;
   errorHandler?: t.ToolNodeConstructorParams['errorHandler'];
   private toolUsageCount: Map<string, number>;
+  /** Maps toolCallId → turn captured in runTool, used by handleRunToolCompletions */
+  private toolCallTurns: Map<string, number> = new Map();
   /** Tool registry for filtering (lazy computation of programmatic maps) */
   private toolRegistry?: t.LCToolRegistry;
   /** Cached programmatic tools (computed once on first PTC call) */
@@ -129,6 +131,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       }
       const turn = this.toolUsageCount.get(call.name) ?? 0;
       this.toolUsageCount.set(call.name, turn + 1);
+      if (call.id != null && call.id !== '') {
+        this.toolCallTurns.set(call.id, turn);
+      }
       const args = call.args;
       const stepId = this.toolCallStepIds?.get(call.id!);
 
@@ -289,7 +294,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
   /**
    * Extracts code execution session context from tool results and stores in Graph.sessions.
-   * Mirrors the session storage logic in Graph.handleToolCallCompleted() for direct execution.
+   * Mirrors the session storage logic in handleRunToolCompletions for direct execution.
    */
   private storeCodeSessionFromResults(
     results: t.ToolExecuteResult[],
@@ -350,6 +355,115 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     }
   }
 
+  /**
+   * Post-processes standard runTool outputs: dispatches ON_RUN_STEP_COMPLETED
+   * and stores code session context. Mirrors the completion handling in
+   * dispatchToolEvents for the event-driven path.
+   *
+   * By handling completions here in graph context (rather than in the
+   * stream consumer via ToolEndHandler), the race between the stream
+   * consumer and graph execution is eliminated.
+   */
+  private handleRunToolCompletions(
+    calls: ToolCall[],
+    outputs: (BaseMessage | Command)[],
+    config: RunnableConfig
+  ): void {
+    for (let i = 0; i < calls.length; i++) {
+      const call = calls[i];
+      const output = outputs[i];
+      const turn = this.toolCallTurns.get(call.id!) ?? 0;
+
+      if (isCommand(output)) {
+        continue;
+      }
+
+      const toolMessage = output as ToolMessage;
+      const toolCallId = call.id ?? '';
+
+      // Skip error ToolMessages when errorHandler already dispatched ON_RUN_STEP_COMPLETED
+      // via handleToolCallErrorStatic. Without this check, errors would be double-dispatched.
+      if (toolMessage.status === 'error' && this.errorHandler != null) {
+        continue;
+      }
+
+      // Store code session context from tool results
+      if (
+        this.sessions &&
+        (call.name === Constants.EXECUTE_CODE ||
+          call.name === Constants.PROGRAMMATIC_TOOL_CALLING)
+      ) {
+        const artifact = toolMessage.artifact as
+          | t.CodeExecutionArtifact
+          | undefined;
+        if (artifact?.session_id != null && artifact.session_id !== '') {
+          const newFiles = artifact.files ?? [];
+          const existingSession = this.sessions.get(Constants.EXECUTE_CODE) as
+            | t.CodeSessionContext
+            | undefined;
+          const existingFiles = existingSession?.files ?? [];
+
+          if (newFiles.length > 0) {
+            const filesWithSession: t.FileRefs = newFiles.map((file) => ({
+              ...file,
+              session_id: artifact.session_id,
+            }));
+            const newFileNames = new Set(filesWithSession.map((f) => f.name));
+            const filteredExisting = existingFiles.filter(
+              (f) => !newFileNames.has(f.name)
+            );
+            this.sessions.set(Constants.EXECUTE_CODE, {
+              session_id: artifact.session_id,
+              files: [...filteredExisting, ...filesWithSession],
+              lastUpdated: Date.now(),
+            });
+          } else {
+            this.sessions.set(Constants.EXECUTE_CODE, {
+              session_id: artifact.session_id,
+              files: existingFiles,
+              lastUpdated: Date.now(),
+            });
+          }
+        }
+      }
+
+      // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
+      const stepId = this.toolCallStepIds?.get(toolCallId) ?? '';
+      if (!stepId) {
+        continue;
+      }
+
+      const contentString =
+        typeof toolMessage.content === 'string'
+          ? toolMessage.content
+          : JSON.stringify(toolMessage.content);
+
+      const tool_call: t.ProcessedToolCall = {
+        args:
+          typeof call.args === 'string'
+            ? (call.args as string)
+            : JSON.stringify((call.args as unknown) ?? {}),
+        name: call.name,
+        id: toolCallId,
+        output: contentString,
+        progress: 1,
+      };
+
+      safeDispatchCustomEvent(
+        GraphEvents.ON_RUN_STEP_COMPLETED,
+        {
+          result: {
+            id: stepId,
+            index: turn,
+            type: 'tool_call' as const,
+            tool_call,
+          },
+        },
+        config
+      );
+    }
+  }
+
   /**
    * Dispatches tool calls to the host via ON_TOOL_EXECUTE event and returns raw ToolMessages.
    * Core logic for event-driven execution, separated from output shaping.
@@ -404,6 +518,14 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       const request = requests.find((r) => r.id === result.toolCallId);
       const toolName = request?.name ?? 'unknown';
       const stepId = this.toolCallStepIds?.get(result.toolCallId) ?? '';
+      if (!stepId) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `[ToolNode] toolCallStepIds missing entry for toolCallId=${result.toolCallId} (tool=${toolName}). ` +
+            'This indicates a race between the stream consumer and graph execution. ' +
+            `Map size: ${this.toolCallStepIds?.size ?? 0}`
+        );
+      }
 
       let toolMessage: ToolMessage;
       let contentString: string;
@@ -476,6 +598,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   protected async run(input: any, config: RunnableConfig): Promise<T> {
+    this.toolCallTurns.clear();
     let outputs: (BaseMessage | Command)[];
 
     if (this.isSendInput(input)) {
@@ -484,6 +607,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         return this.executeViaEvent([input.lg_tool_call], config, input);
       }
       outputs = [await this.runTool(input.lg_tool_call, config)];
+      this.handleRunToolCompletions([input.lg_tool_call], outputs, config);
     } else {
       let messages: BaseMessage[];
       if (Array.isArray(input)) {
@@ -557,6 +681,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             )
             : [];
 
+        if (directCalls.length > 0 && directOutputs.length > 0) {
+          this.handleRunToolCompletions(directCalls, directOutputs, config);
+        }
+
         const eventOutputs: ToolMessage[] =
           eventCalls.length > 0
             ? await this.dispatchToolEvents(eventCalls, config)
@@ -567,6 +695,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         outputs = await Promise.all(
           filteredCalls.map((call) => this.runTool(call, config))
         );
+        this.handleRunToolCompletions(filteredCalls, outputs, config);
       }
     }
 

package/src/tools/handlers.ts

@@ -4,7 +4,7 @@ import { nanoid } from 'nanoid';
 import { ToolMessage } from '@langchain/core/messages';
 import type { AnthropicWebSearchResultBlockParam } from '@/llm/anthropic/types';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
-import type { MultiAgentGraph, StandardGraph } from '@/graphs';
+import type { Graph, MultiAgentGraph, StandardGraph } from '@/graphs';
 import type { AgentContext } from '@/agents/AgentContext';
 import type * as t from '@/types';
 import {
@@ -127,7 +127,7 @@ export async function handleToolCallChunks({
 export const handleToolCalls = async (
   toolCalls?: ToolCall[],
   metadata?: Record<string, unknown>,
-  graph?: StandardGraph | MultiAgentGraph
+  graph?: Graph | StandardGraph | MultiAgentGraph
 ): Promise<void> => {
   if (!graph || !metadata) {
     console.warn('Graph or metadata not found in `handleToolCalls`');