@librechat/agents 3.7.10 → 3.7.12

package/src/tools/ToolNode.ts

@@ -738,6 +738,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
    * even where `agentId` (the subagent-scope marker) is undefined.
    */
   private executingAgentId?: string;
+  private executingAgentName?: string;
+  private rootAgentId?: string;
+  private rootAgentName?: string;
   /** Tool names that bypass event dispatch and execute directly (e.g., graph-managed handoff tools) */
   private directToolNames?: Set<string>;
   /**
@@ -823,6 +826,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     eagerEventToolSuppressions,
     agentId,
     executingAgentId,
+    executingAgentName,
+    rootAgentId,
+    rootAgentName,
     directToolNames,
     interruptingToolNames,
     codeSessionToolNames,
@@ -902,6 +908,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     // Default to agentId so callers constructing ToolNode directly (who pass the
     // existing agentId option) still get attribution without knowing the new option.
     this.executingAgentId = executingAgentId ?? agentId;
+    this.executingAgentName = executingAgentName;
+    this.rootAgentId = rootAgentId;
+    this.rootAgentName = rootAgentName;
     this.directToolNames = directToolNames;
     this.interruptingToolNames =
       interruptingToolNames != null && interruptingToolNames.size > 0
@@ -963,6 +972,16 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           metadata: {
             ...options?.metadata,
             agentId: this.executingAgentId,
+            activeAgentId: this.executingAgentId,
+            ...(this.executingAgentName == null
+              ? {}
+              : { activeAgentName: this.executingAgentName }),
+            ...(this.rootAgentId == null
+              ? {}
+              : { rootAgentId: this.rootAgentId }),
+            ...(this.rootAgentName == null
+              ? {}
+              : { rootAgentName: this.rootAgentName }),
           },
         };
     return withLangfuseRuntimeScope(

package/src/tools/local/LocalProgrammaticToolCalling.ts

@@ -589,17 +589,28 @@ async function runLocalProgrammaticTool(args: {
     programmaticToolName: runnerName,
   });
 
-  if (toolMap == null || toolMap.size === 0) {
-    throw new Error('No toolMap provided for local programmatic execution.');
-  }
-  if (toolDefs == null || toolDefs.length === 0) {
-    throw new Error(
-      'No tool definitions provided for local programmatic execution.'
-    );
+  /* The local program builder supports zero stubs, so a call that selected no
+   * tools needs neither a toolMap nor toolDefs. Injected context is still
+   * required to conclude that. */
+  const needsNoTools =
+    selectedTools.length === 0 &&
+    (args.params.tool_manifest?.length === 0 ||
+      toolDefs != null ||
+      disallowedToolDefs != null);
+
+  if (!needsNoTools) {
+    if (toolMap == null || toolMap.size === 0) {
+      throw new Error('No toolMap provided for local programmatic execution.');
+    }
+    if (toolDefs == null || toolDefs.length === 0) {
+      throw new Error(
+        'No tool definitions provided for local programmatic execution.'
+      );
+    }
   }
 
   const { effectiveTools, effectiveMap } = createEffectiveToolMap(
-    toolMap,
+    toolMap ?? new Map(),
     selectedTools
   );
   const bridge = await createToolBridge(effectiveMap, hookContext);

package/src/types/tools.ts

@@ -148,6 +148,11 @@ export type ToolNodeOptions = {
   /** ID of the agent that owns this tool node, surfaced to hooks as `executingAgentId`
    * so a batch can be attributed to a specific agent even where `agentId` is undefined. */
   executingAgentId?: string;
+  /** Name of the agent that owns this tool node, used for active Langfuse attribution. */
+  executingAgentName?: string;
+  /** Root graph-agent identity retained alongside the currently executing tool owner. */
+  rootAgentId?: string;
+  rootAgentName?: string;
   /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
   directToolNames?: Set<string>;
   /**