@librechat/agents 3.6.9 → 3.6.11

package/src/tools/local/resolveLocalExecutionTools.ts

@@ -4,6 +4,7 @@ import {
   createLocalProgrammaticToolCallingTool,
 } from './LocalProgrammaticToolCalling';
 import {
+  CLOUDFLARE_CODING_TOOL_NAMES,
   createCloudflareCodingToolBundle,
   createCloudflareCodingTools,
   createCloudflareExecutionTool,
@@ -17,6 +18,10 @@ import {
   createLocalBashExecutionTool,
   createLocalCodeExecutionTool,
 } from './LocalExecutionTools';
+import {
+  allowsToolCaller,
+  isToolDefinitionActive,
+} from '@/tools/CallerCapabilities';
 import {
   Constants,
   CODE_EXECUTION_TOOLS,
@@ -26,6 +31,8 @@ import {
 type ResolveLocalToolsResult = {
   toolMap: t.ToolMap;
   directToolNames: Set<string>;
+  /** Names whose toolMap entries were created or replaced by this resolver. */
+  localImplementationNames: Set<string>;
   /**
    * Set when `local.fileCheckpointing === true` AND the auto-bind
    * coding suite is in use. ToolNode stashes this on the node and
@@ -58,6 +65,48 @@ function shouldIncludeCodingTools(config?: t.ToolExecutionConfig): boolean {
   );
 }
 
+export function isProgrammaticRunnerAutoBound(
+  name: string,
+  config?: t.ToolExecutionConfig
+): boolean {
+  if (
+    !shouldIncludeCodingTools(config) ||
+    (name !== Constants.PROGRAMMATIC_TOOL_CALLING &&
+      name !== Constants.BASH_PROGRAMMATIC_TOOL_CALLING)
+  ) {
+    return false;
+  }
+  if (shouldUseCloudflareSandboxExecution(config)) {
+    return getSelectedCloudflareCodingToolNames(
+      getCloudflareConfig(config)
+    ).has(name);
+  }
+  return shouldUseLocalExecution(config);
+}
+
+/** Mirrors whether resolver policy creates or replaces this runner locally. */
+export function isProgrammaticRunnerResolvedDirectly(
+  name: string,
+  config?: t.ToolExecutionConfig,
+  hasExplicitBinding: boolean = false
+): boolean {
+  if (isProgrammaticRunnerAutoBound(name, config)) {
+    return true;
+  }
+  if (
+    !hasExplicitBinding ||
+    (name !== Constants.PROGRAMMATIC_TOOL_CALLING &&
+      name !== Constants.BASH_PROGRAMMATIC_TOOL_CALLING)
+  ) {
+    return false;
+  }
+  return (
+    (shouldUseLocalExecution(config) ||
+      shouldUseCloudflareSandboxExecution(config)) &&
+    !shouldIncludeCodingTools(config)
+  );
+}
+
 function getCloudflareConfig(
   config?: t.ToolExecutionConfig
 ): t.CloudflareSandboxExecutionConfig {
@@ -72,7 +121,12 @@ function getCloudflareConfig(
 function getSelectedCloudflareCodingToolNames(
   config: t.CloudflareSandboxExecutionConfig
 ): Set<string> {
-  return new Set(config.codingToolNames ?? LOCAL_CODING_BUNDLE_NAMES);
+  const requestedNames = new Set(
+    config.codingToolNames ?? CLOUDFLARE_CODING_TOOL_NAMES
+  );
+  return new Set(
+    CLOUDFLARE_CODING_TOOL_NAMES.filter((name) => requestedNames.has(name))
+  );
 }
 
 function filterCloudflareCodingToolAllowlist(
@@ -150,9 +204,43 @@ function mergeToolsByName(
   return orderedTools;
 }
 
+function filterToolsForDirectCaller(
+  tools: t.GraphTools | undefined,
+  toolRegistry?: t.LCToolRegistry,
+  discoveredToolNames: ReadonlySet<string> = new Set()
+): t.GraphTools | undefined {
+  if (tools == null || toolRegistry == null) {
+    return tools;
+  }
+  return tools.filter((tool) => {
+    if (!('name' in tool) || typeof tool.name !== 'string') {
+      return true;
+    }
+    const toolDef = toolRegistry.get(tool.name);
+    return (
+      toolDef == null ||
+      (allowsToolCaller(toolDef, 'direct') &&
+        isToolDefinitionActive(toolDef, discoveredToolNames))
+    );
+  });
+}
+
+function addDirectToolName(
+  directToolNames: Set<string>,
+  name: string,
+  toolRegistry?: t.LCToolRegistry
+): void {
+  const toolDef = toolRegistry?.get(name);
+  if (toolDef == null || allowsToolCaller(toolDef, 'direct')) {
+    directToolNames.add(name);
+  }
+}
+
 export function resolveLocalToolsForBinding(args: {
   tools?: t.GraphTools;
   toolExecution?: t.ToolExecutionConfig;
+  toolRegistry?: t.LCToolRegistry;
+  discoveredToolNames?: ReadonlySet<string>;
 }): t.GraphTools | undefined {
   if (
     !shouldUseLocalExecution(args.toolExecution) &&
@@ -166,9 +254,13 @@ export function resolveLocalToolsForBinding(args: {
     if (shouldIncludeCodingTools(args.toolExecution)) {
       const selectedNames =
         getSelectedCloudflareCodingToolNames(cloudflareConfig);
-      return mergeToolsByName(
-        filterCloudflareCodingToolAllowlist(args.tools, selectedNames),
-        createCloudflareCodingTools(cloudflareConfig)
+      return filterToolsForDirectCaller(
+        mergeToolsByName(
+          filterCloudflareCodingToolAllowlist(args.tools, selectedNames),
+          createCloudflareCodingTools(cloudflareConfig)
+        ),
+        args.toolRegistry,
+        args.discoveredToolNames
       );
     }
 
@@ -187,14 +279,23 @@ export function resolveLocalToolsForBinding(args: {
           cloudflareTool != null
       );
 
-    return replacements.length === 0
+    const resolvedTools = replacements.length === 0
       ? args.tools
       : mergeToolsByName(args.tools, replacements);
+    return filterToolsForDirectCaller(
+      resolvedTools,
+      args.toolRegistry,
+      args.discoveredToolNames
+    );
   }
 
   const localConfig = args.toolExecution?.local ?? {};
   if (shouldIncludeCodingTools(args.toolExecution)) {
-    return mergeToolsByName(args.tools, createLocalCodingTools(localConfig));
+    return filterToolsForDirectCaller(
+      mergeToolsByName(args.tools, createLocalCodingTools(localConfig)),
+      args.toolRegistry,
+      args.discoveredToolNames
+    );
   }
 
   const replacements = ((args.tools as t.GenericTool[] | undefined) ?? [])
@@ -209,9 +310,14 @@ export function resolveLocalToolsForBinding(args: {
     )
     .filter((localTool): localTool is t.GenericTool => localTool != null);
 
-  return replacements.length === 0
+  const resolvedTools = replacements.length === 0
     ? args.tools
     : mergeToolsByName(args.tools, replacements);
+  return filterToolsForDirectCaller(
+    resolvedTools,
+    args.toolRegistry,
+    args.discoveredToolNames
+  );
 }
 
 export function resolveLocalToolRegistry(args: {
@@ -228,19 +334,69 @@ export function resolveLocalToolRegistry(args: {
       getCloudflareConfig(args.toolExecution)
     )
     : undefined;
+
+  if (selectedNames != null) {
+    const callableInsideCloudflare = new Set(selectedNames);
+    callableInsideCloudflare.delete(Constants.PROGRAMMATIC_TOOL_CALLING);
+    callableInsideCloudflare.delete(Constants.BASH_PROGRAMMATIC_TOOL_CALLING);
+    for (const [name, definition] of registry) {
+      if (callableInsideCloudflare.has(name)) {
+        continue;
+      }
+      const allowedCallers = definition.allowed_callers ?? ['direct'];
+      if (allowedCallers.includes('code_execution')) {
+        registry.set(name, {
+          ...definition,
+          allowed_callers: allowedCallers.filter(
+            (caller) => caller !== 'code_execution'
+          ),
+        });
+      }
+    }
+  }
+
   for (const definition of createLocalCodingToolDefinitions()) {
     if (selectedNames != null && !selectedNames.has(definition.name)) {
       registry.delete(definition.name);
       continue;
     }
-    registry.set(definition.name, definition);
+    const existingDefinition = registry.get(definition.name);
+    registry.set(
+      definition.name,
+      existingDefinition == null
+        ? definition
+        : { ...definition, ...existingDefinition }
+    );
   }
   return registry;
 }
 
+/** Names that this execution config creates or replaces in the local tool map. */
+export function resolveLocalImplementationNames(
+  toolNames: Iterable<string>,
+  toolExecution?: t.ToolExecutionConfig
+): Set<string> {
+  if (
+    !shouldUseLocalExecution(toolExecution) &&
+    !shouldUseCloudflareSandboxExecution(toolExecution)
+  ) {
+    return new Set();
+  }
+  if (shouldIncludeCodingTools(toolExecution)) {
+    return shouldUseCloudflareSandboxExecution(toolExecution)
+      ? getSelectedCloudflareCodingToolNames(getCloudflareConfig(toolExecution))
+      : new Set(LOCAL_CODING_BUNDLE_NAMES);
+  }
+  const existingNames = new Set(toolNames);
+  return new Set(
+    [...CODE_EXECUTION_TOOLS].filter((name) => existingNames.has(name))
+  );
+}
+
 export function resolveLocalExecutionTools(args: {
   toolMap: t.ToolMap;
   toolExecution?: t.ToolExecutionConfig;
+  toolRegistry?: t.LCToolRegistry;
   /**
    * Caller-provided checkpointer that overrides the bundle's
    * auto-created one. The Graph layer threads a single per-Run
@@ -252,6 +408,10 @@ export function resolveLocalExecutionTools(args: {
   fileCheckpointer?: t.LocalFileCheckpointer;
 }): ResolveLocalToolsResult {
   const directToolNames = new Set<string>();
+  const localImplementationNames = resolveLocalImplementationNames(
+    args.toolMap.keys(),
+    args.toolExecution
+  );
   if (
     !shouldUseLocalExecution(args.toolExecution) &&
     !shouldUseCloudflareSandboxExecution(args.toolExecution)
@@ -259,6 +419,7 @@ export function resolveLocalExecutionTools(args: {
     return {
       toolMap: args.toolMap,
       directToolNames,
+      localImplementationNames,
     };
   }
 
@@ -281,14 +442,24 @@ export function resolveLocalExecutionTools(args: {
         fileCheckpointer = bundle.checkpointer;
         for (const cloudflareTool of bundle.tools) {
           toolMap.set(cloudflareTool.name, cloudflareTool);
-          directToolNames.add(cloudflareTool.name);
+          localImplementationNames.add(cloudflareTool.name);
+          addDirectToolName(
+            directToolNames,
+            cloudflareTool.name,
+            args.toolRegistry
+          );
         }
       } else {
         for (const cloudflareTool of createCloudflareCodingTools(
           cloudflareConfig
         )) {
           toolMap.set(cloudflareTool.name, cloudflareTool);
-          directToolNames.add(cloudflareTool.name);
+          localImplementationNames.add(cloudflareTool.name);
+          addDirectToolName(
+            directToolNames,
+            cloudflareTool.name,
+            args.toolRegistry
+          );
         }
       }
     }
@@ -307,10 +478,16 @@ export function resolveLocalExecutionTools(args: {
       }
 
       toolMap.set(name, cloudflareTool);
-      directToolNames.add(name);
+      localImplementationNames.add(name);
+      addDirectToolName(directToolNames, name, args.toolRegistry);
     }
 
-    return { toolMap, directToolNames, fileCheckpointer };
+    return {
+      toolMap,
+      directToolNames,
+      localImplementationNames,
+      fileCheckpointer,
+    };
   }
 
   const localConfig = args.toolExecution?.local ?? {};
@@ -332,12 +509,22 @@ export function resolveLocalExecutionTools(args: {
       fileCheckpointer = bundle.checkpointer;
       for (const localTool of bundle.tools) {
         toolMap.set(localTool.name, localTool);
-        directToolNames.add(localTool.name);
+        localImplementationNames.add(localTool.name);
+        addDirectToolName(
+          directToolNames,
+          localTool.name,
+          args.toolRegistry
+        );
       }
     } else {
       for (const localTool of createLocalCodingTools(localConfig)) {
         toolMap.set(localTool.name, localTool);
-        directToolNames.add(localTool.name);
+        localImplementationNames.add(localTool.name);
+        addDirectToolName(
+          directToolNames,
+          localTool.name,
+          args.toolRegistry
+        );
       }
     }
   }
@@ -363,8 +550,14 @@ export function resolveLocalExecutionTools(args: {
     }
 
     toolMap.set(name, localTool);
-    directToolNames.add(name);
+    localImplementationNames.add(name);
+    addDirectToolName(directToolNames, name, args.toolRegistry);
   }
 
-  return { toolMap, directToolNames, fileCheckpointer };
+  return {
+    toolMap,
+    directToolNames,
+    localImplementationNames,
+    fileCheckpointer,
+  };
 }

package/src/tools/ptcTimeout.ts

@@ -22,6 +22,12 @@ export type ProgrammaticToolCallingJsonSchema = {
       minLength: number;
       description: string;
     };
+    tool_manifest: {
+      type: 'array';
+      items: { type: 'string' };
+      uniqueItems: true;
+      description: string;
+    };
     timeout: TimeoutSchema;
   };
   required: readonly ['code'];

package/src/types/graph.ts

@@ -31,6 +31,7 @@ import type {
   ToolEndEvent,
   GenericTool,
   LCTool,
+  ToolExecutionConfig,
   ToolExecuteBatchRequest,
 } from '@/types/tools';
 import type {
@@ -338,6 +339,8 @@ export type StandardGraphInput = {
   runId?: string;
   signal?: AbortSignal;
   agents: AgentInputs[];
+  /** Execution backend used to resolve the effective tool registry. */
+  toolExecution?: ToolExecutionConfig;
   langfuse?: LangfuseConfig;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;

package/src/types/tools.ts

@@ -1,17 +1,17 @@
 // src/types/tools.ts
-import type { StructuredToolInterface } from '@langchain/core/tools';
 import type {
   RunnableConfig,
   RunnableToolLike,
 } from '@langchain/core/runnables';
+import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
-import type { RunBreakerScope } from '@/llm/streamLimits';
 import type {
   MessageContentComplex,
   RunStepResumeState,
   ToolErrorData,
 } from './stream';
+import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
+import type { RunBreakerScope } from '@/llm/streamLimits';
 import type { HumanInTheLoopConfig } from './hitl';
 import type { LangfuseConfig } from './graph';
 import type { HookRegistry } from '@/hooks';
@@ -133,6 +133,8 @@ export type ToolNodeOptions = {
   ) => Promise<boolean | void>;
   /** Tool registry for lazy computation of programmatic tools and tool search */
   toolRegistry?: LCToolRegistry;
+  /** Returns the owning agent's currently discovered deferred tool names. */
+  getDiscoveredToolNames?: () => readonly string[];
   /** Reference to Graph's sessions map for automatic session injection */
   sessions?: ToolSessionMap;
   /** Partition within `sessions` used by this agent's code tools. */
@@ -555,6 +557,19 @@ export type ToolCallRequest = {
   runtimeSessionHint?: string;
 };
 
+/**
+ * Serializable view of the active tools grouped by their effective caller
+ * capabilities. Event-driven hosts use this snapshot to preserve the SDK's
+ * live deferred-tool discovery state without reimplementing its policy.
+ */
+export type CallerCapabilityProjectionSnapshot = {
+  version: 1;
+  directToolNames: string[];
+  codeExecutionToolNames: string[];
+  directOnlyToolNames: string[];
+  codeExecutionOnlyToolNames: string[];
+};
+
 /** Batch request containing ALL tool calls for a graph step */
 export type ToolExecuteBatchRequest = {
   /** All tool calls from the AIMessage */
@@ -563,6 +578,11 @@ export type ToolExecuteBatchRequest = {
   userId?: string;
   /** Agent ID for context */
   agentId?: string;
+  /**
+   * SDK-owned snapshot of the active caller capability projection. Optional
+   * so older event handlers remain compatible with newer SDKs.
+   */
+  callerCapabilityProjection?: CallerCapabilityProjectionSnapshot;
   /** Runtime configurable from RunnableConfig (includes user, userMCPAuthMap, etc.) */
   configurable?: Record<string, unknown>;
   /** Runtime metadata from RunnableConfig (includes thread_id, run_id, provider, etc.) */
@@ -1171,6 +1191,15 @@ export type ToolExecutionConfig = {
 export type ProgrammaticCache = {
   toolMap: ToolMap;
   toolDefs: LCTool[];
+  /** Actual outer runner name used for caller-policy diagnostics. */
+  programmaticToolName?: string;
+  /**
+   * Known tools that cannot be invoked from programmatic execution. Kept
+   * separate from `toolDefs` so the Programmatic Tool Manifest can be
+   * validated before the execution runtime starts without exposing their
+   * schemas to that runtime.
+   */
+  disallowedToolDefs?: LCTool[];
   /**
    * Hook context plumbed through by ToolNode for the local
    * programmatic-tool path so the in-process bridge can run

package/src/utils/toolContent.ts

@@ -1818,7 +1818,7 @@ function classifyToolContentBlock(
     }
   }
   const remaining = { value: MAX_ATOMIC_VALIDATION_WORK };
-  let kind = TOOL_BLOCK_OPAQUE;
+  let kind: number;
   try {
     if (
       hasUnsafeCallableToJSON(
@@ -2701,7 +2701,7 @@ export function cloneToolMessageWithContent(
     status: message.status,
     artifact,
     metadata: message.metadata,
-    additional_kwargs: message.additional_kwargs,
+    additional_kwargs: { ...message.additional_kwargs },
     response_metadata: message.response_metadata,
   });
 }