@librechat/agents 3.1.21 → 3.1.23

package/dist/types/index.d.ts

@@ -9,7 +9,7 @@ export * from './tools/CodeExecutor';
 export * from './tools/ProgrammaticToolCalling';
 export * from './tools/ToolSearch';
 export * from './tools/ToolNode';
-export * from './tools/createSchemaOnlyTool';
+export * from './tools/schema';
 export * from './tools/handlers';
 export * from './tools/search';
 export * from './common';

package/dist/types/tools/ToolNode.d.ts

@@ -22,7 +22,9 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private eventDrivenMode;
     /** Tool definitions for event-driven mode */
     private toolDefinitions?;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, toolDefinitions, }: t.ToolNodeConstructorParams);
+    /** Agent ID for event-driven mode */
+    private agentId?;
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, toolDefinitions, agentId, }: t.ToolNodeConstructorParams);
     /**
      * Returns cached programmatic tools, computing once on first access.
      * Single iteration builds both toolMap and toolDefs simultaneously.

package/dist/types/types/tools.d.ts

@@ -35,6 +35,8 @@ export type ToolNodeOptions = {
     eventDrivenMode?: boolean;
     /** Tool definitions for event-driven mode (used for context, not invocation) */
     toolDefinitions?: Map<string, LCTool>;
+    /** Agent ID for event-driven mode (used to identify which agent's context to use) */
+    agentId?: string;
 };
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {
@@ -128,6 +130,10 @@ export type ToolExecuteBatchRequest = {
     userId?: string;
     /** Agent ID for context */
     agentId?: string;
+    /** Runtime configurable from RunnableConfig (includes user, userMCPAuthMap, etc.) */
+    configurable?: Record<string, unknown>;
+    /** Runtime metadata from RunnableConfig (includes thread_id, run_id, provider, etc.) */
+    metadata?: Record<string, unknown>;
     /** Promise resolver - handler calls this with ALL results */
     resolve: (results: ToolExecuteResult[]) => void;
     /** Promise rejector - handler calls this on fatal error */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.21",
+  "version": "3.1.23",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/agents/AgentContext.ts

@@ -10,6 +10,7 @@ import type {
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import type { createPruneMessages } from '@/messages';
+import { createSchemaOnlyTools } from '@/tools/schema';
 import { ContentTypes, Providers } from '@/common';
 import { toJsonSchema } from '@/utils/schema';
 
@@ -571,40 +572,70 @@ export class AgentContext {
 
   /**
    * Gets tools that should be bound to the LLM.
-   * Includes:
+   * In event-driven mode (toolDefinitions present, tools empty), creates schema-only tools.
+   * Otherwise filters tool instances based on:
    * 1. Non-deferred tools with allowed_callers: ['direct']
    * 2. Discovered tools (from tool search)
    * @returns Array of tools to bind to model
    */
   getToolsForBinding(): t.GraphTools | undefined {
+    /** Event-driven mode: create schema-only tools from definitions */
+    if (this.toolDefinitions && this.toolDefinitions.length > 0) {
+      return this.getEventDrivenToolsForBinding();
+    }
+
+    /** Traditional mode: filter actual tool instances */
     if (!this.tools || !this.toolRegistry) {
       return this.tools;
     }
 
-    const toolsToInclude = this.tools.filter((tool) => {
+    return this.filterToolsForBinding(this.tools);
+  }
+
+  /** Creates schema-only tools from toolDefinitions for event-driven mode */
+  private getEventDrivenToolsForBinding(): t.GraphTools {
+    if (!this.toolDefinitions) {
+      return [];
+    }
+
+    const defsToInclude = this.toolDefinitions.filter((def) => {
+      const allowedCallers = def.allowed_callers ?? ['direct'];
+      if (!allowedCallers.includes('direct')) {
+        return false;
+      }
+      if (
+        def.defer_loading === true &&
+        !this.discoveredToolNames.has(def.name)
+      ) {
+        return false;
+      }
+      return true;
+    });
+
+    return createSchemaOnlyTools(defsToInclude) as t.GraphTools;
+  }
+
+  /** Filters tool instances for binding based on registry config */
+  private filterToolsForBinding(tools: t.GraphTools): t.GraphTools {
+    return tools.filter((tool) => {
       if (!('name' in tool)) {
-        return true; // No name, include by default
+        return true;
       }
 
       const toolDef = this.toolRegistry?.get(tool.name);
       if (!toolDef) {
-        return true; // Not in registry, include by default
+        return true;
       }
 
-      // Check if discovered (overrides defer_loading)
       if (this.discoveredToolNames.has(tool.name)) {
-        // Discovered tools must still have allowed_callers: ['direct']
         const allowedCallers = toolDef.allowed_callers ?? ['direct'];
         return allowedCallers.includes('direct');
       }
 
-      // Not discovered: must be direct-callable AND not deferred
       const allowedCallers = toolDef.allowed_callers ?? ['direct'];
       return (
         allowedCallers.includes('direct') && toolDef.defer_loading !== true
       );
     });
-
-    return toolsToInclude;
   }
 }

package/src/graphs/Graph.ts

@@ -58,9 +58,9 @@ import {
 } from '@/utils';
 import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
-import { createSchemaOnlyTools } from '@/tools/createSchemaOnlyTool';
 import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
 import { safeDispatchCustomEvent } from '@/utils/events';
+import { createSchemaOnlyTools } from '@/tools/schema';
 import { AgentContext } from '@/agents/AgentContext';
 import { createFakeStreamingLLM } from '@/llm/fake';
 import { HandlerRegistry } from '@/events';
@@ -472,6 +472,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         sessions: this.sessions,
         eventDrivenMode: true,
         toolDefinitions: toolDefMap,
+        agentId: agentContext?.agentId,
       });
     }
 

package/src/index.ts

@@ -14,7 +14,7 @@ export * from './tools/CodeExecutor';
 export * from './tools/ProgrammaticToolCalling';
 export * from './tools/ToolSearch';
 export * from './tools/ToolNode';
-export * from './tools/createSchemaOnlyTool';
+export * from './tools/schema';
 export * from './tools/handlers';
 export * from './tools/search';
 

package/src/tools/ToolNode.ts

@@ -49,6 +49,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   private eventDrivenMode: boolean = false;
   /** Tool definitions for event-driven mode */
   private toolDefinitions?: Map<string, t.LCTool>;
+  /** Agent ID for event-driven mode */
+  private agentId?: string;
 
   constructor({
     tools,
@@ -63,6 +65,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     sessions,
     eventDrivenMode,
     toolDefinitions,
+    agentId,
   }: t.ToolNodeConstructorParams) {
     super({ name, tags, func: (input, config) => this.run(input, config) });
     this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
@@ -75,6 +78,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     this.sessions = sessions;
     this.eventDrivenMode = eventDrivenMode ?? false;
     this.toolDefinitions = toolDefinitions;
+    this.agentId = agentId;
   }
 
   /**
@@ -279,7 +283,11 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         const request: t.ToolExecuteBatchRequest = {
           toolCalls: requests,
           userId: config.configurable?.user_id as string | undefined,
-          agentId: config.configurable?.agent_id as string | undefined,
+          agentId: this.agentId,
+          configurable: config.configurable as
+            | Record<string, unknown>
+            | undefined,
+          metadata: config.metadata as Record<string, unknown> | undefined,
           resolve,
           reject,
         };
@@ -289,27 +297,61 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     );
 
     const outputs: ToolMessage[] = results.map((result) => {
-      const toolName =
-        requests.find((r) => r.id === result.toolCallId)?.name ?? 'unknown';
+      const request = requests.find((r) => r.id === result.toolCallId);
+      const toolName = request?.name ?? 'unknown';
+      const stepId = this.toolCallStepIds?.get(result.toolCallId) ?? '';
+
+      let toolMessage: ToolMessage;
+      let contentString: string;
 
       if (result.status === 'error') {
-        return new ToolMessage({
+        contentString = `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`;
+        toolMessage = new ToolMessage({
           status: 'error',
-          content: `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`,
+          content: contentString,
           name: toolName,
           tool_call_id: result.toolCallId,
         });
-      }
-
-      return new ToolMessage({
-        status: 'success',
-        content:
+      } else {
+        contentString =
           typeof result.content === 'string'
             ? result.content
-            : JSON.stringify(result.content),
+            : JSON.stringify(result.content);
+        toolMessage = new ToolMessage({
+          status: 'success',
+          content: contentString,
+          name: toolName,
+          tool_call_id: result.toolCallId,
+        });
+      }
+
+      const tool_call: t.ProcessedToolCall = {
+        args:
+          typeof request?.args === 'string'
+            ? request.args
+            : JSON.stringify(request?.args ?? {}),
         name: toolName,
-        tool_call_id: result.toolCallId,
-      });
+        id: result.toolCallId,
+        output: contentString,
+        progress: 1,
+      };
+
+      const runStepCompletedData = {
+        result: {
+          id: stepId,
+          index: request?.turn ?? 0,
+          type: 'tool_call' as const,
+          tool_call,
+        },
+      };
+
+      safeDispatchCustomEvent(
+        GraphEvents.ON_RUN_STEP_COMPLETED,
+        runStepCompletedData,
+        config
+      );
+
+      return toolMessage;
     });
 
     return (Array.isArray(input) ? outputs : { messages: outputs }) as T;

package/src/types/tools.ts

@@ -45,6 +45,8 @@ export type ToolNodeOptions = {
   eventDrivenMode?: boolean;
   /** Tool definitions for event-driven mode (used for context, not invocation) */
   toolDefinitions?: Map<string, LCTool>;
+  /** Agent ID for event-driven mode (used to identify which agent's context to use) */
+  agentId?: string;
 };
 
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
@@ -159,6 +161,10 @@ export type ToolExecuteBatchRequest = {
   userId?: string;
   /** Agent ID for context */
   agentId?: string;
+  /** Runtime configurable from RunnableConfig (includes user, userMCPAuthMap, etc.) */
+  configurable?: Record<string, unknown>;
+  /** Runtime metadata from RunnableConfig (includes thread_id, run_id, provider, etc.) */
+  metadata?: Record<string, unknown>;
   /** Promise resolver - handler calls this with ALL results */
   resolve: (results: ToolExecuteResult[]) => void;
   /** Promise rejector - handler calls this on fatal error */

package/dist/cjs/tools/createSchemaOnlyTool.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createSchemaOnlyTool.cjs","sources":["../../../src/tools/createSchemaOnlyTool.ts"],"sourcesContent":["import { tool, type StructuredToolInterface } from '@langchain/core/tools';\nimport type { LCTool } from '@/types';\n\n/**\n * Creates a schema-only tool for LLM binding in event-driven mode.\n * These tools have valid schemas for the LLM to understand but should\n * never be invoked directly - ToolNode handles execution via events.\n */\nexport function createSchemaOnlyTool(\n  definition: LCTool\n): StructuredToolInterface {\n  const { name, description, parameters, responseFormat } = definition;\n\n  return tool(\n    async () => {\n      throw new Error(\n        `Tool \"${name}\" should not be invoked directly in event-driven mode. ` +\n          'ToolNode should dispatch ON_TOOL_EXECUTE events instead.'\n      );\n    },\n    {\n      name,\n      description: description ?? '',\n      schema: parameters ?? { type: 'object', properties: {} },\n      responseFormat: responseFormat ?? 'content_and_artifact',\n    }\n  );\n}\n\n/**\n * Creates schema-only tools for all definitions in an array.\n */\nexport function createSchemaOnlyTools(\n  definitions: LCTool[]\n): StructuredToolInterface[] {\n  return definitions.map((def) => createSchemaOnlyTool(def));\n}\n"],"names":["tool"],"mappings":";;;;AAGA;;;;AAIG;AACG,SAAU,oBAAoB,CAClC,UAAkB,EAAA;IAElB,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,UAAU;AAEpE,IAAA,OAAOA,UAAI,CACT,YAAW;AACT,QAAA,MAAM,IAAI,KAAK,CACb,CAAA,MAAA,EAAS,IAAI,CAAyD,uDAAA,CAAA;AACpE,YAAA,0DAA0D,CAC7D;AACH,KAAC,EACD;QACE,IAAI;QACJ,WAAW,EAAE,WAAW,IAAI,EAAE;QAC9B,MAAM,EAAE,UAAU,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE;QACxD,cAAc,EAAE,cAAc,IAAI,sBAAsB;AACzD,KAAA,CACF;AACH;AAEA;;AAEG;AACG,SAAU,qBAAqB,CACnC,WAAqB,EAAA;AAErB,IAAA,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,oBAAoB,CAAC,GAAG,CAAC,CAAC;AAC5D;;;;;"}

package/dist/esm/tools/createSchemaOnlyTool.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createSchemaOnlyTool.mjs","sources":["../../../src/tools/createSchemaOnlyTool.ts"],"sourcesContent":["import { tool, type StructuredToolInterface } from '@langchain/core/tools';\nimport type { LCTool } from '@/types';\n\n/**\n * Creates a schema-only tool for LLM binding in event-driven mode.\n * These tools have valid schemas for the LLM to understand but should\n * never be invoked directly - ToolNode handles execution via events.\n */\nexport function createSchemaOnlyTool(\n  definition: LCTool\n): StructuredToolInterface {\n  const { name, description, parameters, responseFormat } = definition;\n\n  return tool(\n    async () => {\n      throw new Error(\n        `Tool \"${name}\" should not be invoked directly in event-driven mode. ` +\n          'ToolNode should dispatch ON_TOOL_EXECUTE events instead.'\n      );\n    },\n    {\n      name,\n      description: description ?? '',\n      schema: parameters ?? { type: 'object', properties: {} },\n      responseFormat: responseFormat ?? 'content_and_artifact',\n    }\n  );\n}\n\n/**\n * Creates schema-only tools for all definitions in an array.\n */\nexport function createSchemaOnlyTools(\n  definitions: LCTool[]\n): StructuredToolInterface[] {\n  return definitions.map((def) => createSchemaOnlyTool(def));\n}\n"],"names":[],"mappings":";;AAGA;;;;AAIG;AACG,SAAU,oBAAoB,CAClC,UAAkB,EAAA;IAElB,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,UAAU;AAEpE,IAAA,OAAO,IAAI,CACT,YAAW;AACT,QAAA,MAAM,IAAI,KAAK,CACb,CAAA,MAAA,EAAS,IAAI,CAAyD,uDAAA,CAAA;AACpE,YAAA,0DAA0D,CAC7D;AACH,KAAC,EACD;QACE,IAAI;QACJ,WAAW,EAAE,WAAW,IAAI,EAAE;QAC9B,MAAM,EAAE,UAAU,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE;QACxD,cAAc,EAAE,cAAc,IAAI,sBAAsB;AACzD,KAAA,CACF;AACH;AAEA;;AAEG;AACG,SAAU,qBAAqB,CACnC,WAAqB,EAAA;AAErB,IAAA,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,oBAAoB,CAAC,GAAG,CAAC,CAAC;AAC5D;;;;"}