@librechat/agents 3.0.41 → 3.0.43

package/src/common/enum.ts

@@ -160,7 +160,7 @@ export enum Constants {
   OFFICIAL_CODE_BASEURL = 'https://api.librechat.ai/v1',
   EXECUTE_CODE = 'execute_code',
   TOOL_SEARCH_REGEX = 'tool_search_regex',
-  PROGRAMMATIC_TOOL_CALLING = 'programmatic_code_execution',
+  PROGRAMMATIC_TOOL_CALLING = 'run_tools_with_code',
   WEB_SEARCH = 'web_search',
   CONTENT_AND_ARTIFACT = 'content_and_artifact',
   LC_TRANSFER_TO_ = 'lc_transfer_to_',

package/src/graphs/Graph.ts

@@ -46,6 +46,7 @@ import {
   formatContentStrings,
   createPruneMessages,
   addCacheControl,
+  extractToolDiscoveries,
 } from '@/messages';
 import {
   resetIfNotEmpty,
@@ -456,8 +457,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       errorHandler: (data, metadata) =>
         StandardGraph.handleToolCallErrorStatic(this, data, metadata),
       toolRegistry: agentContext?.toolRegistry,
-      programmaticToolMap: agentContext?.getProgrammaticToolMap(),
-      programmaticToolDefs: agentContext?.getProgrammaticToolDefs(),
     });
   }
 
@@ -608,7 +607,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     client.abortHandler = undefined;
   }
 
-  createCallModel(agentId = 'default', currentModel?: t.ChatModel) {
+  createCallModel(agentId = 'default') {
     return async (
       state: t.BaseGraphState,
       config?: RunnableConfig
@@ -621,15 +620,31 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         throw new Error(`Agent context not found for agentId: ${agentId}`);
       }
 
-      const model = this.overrideModel ?? currentModel;
-      if (!model) {
-        throw new Error('No Graph model found');
-      }
       if (!config) {
         throw new Error('No config provided');
       }
 
-      // Ensure token calculations are complete before proceeding
+      const { messages } = state;
+
+      // Extract tool discoveries from current turn only (similar to formatArtifactPayload pattern)
+      const discoveredNames = extractToolDiscoveries(messages);
+      if (discoveredNames.length > 0) {
+        agentContext.markToolsAsDiscovered(discoveredNames);
+      }
+
+      const toolsForBinding = agentContext.getToolsForBinding();
+      let model =
+        this.overrideModel ??
+        this.initializeModel({
+          tools: toolsForBinding,
+          provider: agentContext.provider,
+          clientOptions: agentContext.clientOptions,
+        });
+
+      if (agentContext.systemRunnable) {
+        model = agentContext.systemRunnable.pipe(model as Runnable);
+      }
+
       if (agentContext.tokenCalculationPromise) {
         await agentContext.tokenCalculationPromise;
       }
@@ -637,7 +652,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         config.signal = this.signal;
       }
       this.config = config;
-      const { messages } = state;
 
       let messagesToUse = messages;
       if (
@@ -849,36 +863,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       throw new Error(`Agent context not found for agentId: ${agentId}`);
     }
 
-    // Filter tools for LLM binding: only tools with allowed_callers including 'direct'
-    // Default: if allowed_callers is not specified, tool is bound to LLM (direct)
-    let toolsForLLM = agentContext.tools;
-    if (agentContext.toolRegistry != null && agentContext.tools != null) {
-      toolsForLLM = agentContext.tools.filter((tool) => {
-        const toolDef =
-          'name' in tool
-            ? agentContext.toolRegistry?.get(tool.name)
-            : undefined;
-        if (!toolDef) {
-          // Tool not in registry - bind to LLM by default
-          return true;
-        }
-        if (!toolDef.allowed_callers) {
-          return true;
-        }
-        return toolDef.allowed_callers.includes('direct');
-      });
-    }
-
-    let currentModel = this.initializeModel({
-      tools: toolsForLLM,
-      provider: agentContext.provider,
-      clientOptions: agentContext.clientOptions,
-    });
-
-    if (agentContext.systemRunnable) {
-      currentModel = agentContext.systemRunnable.pipe(currentModel);
-    }
-
     const agentNode = `${AGENT}${agentId}` as const;
     const toolNode = `${TOOLS}${agentId}` as const;
 
@@ -898,7 +882,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     });
 
     const workflow = new StateGraph(StateAnnotation)
-      .addNode(agentNode, this.createCallModel(agentId, currentModel))
+      .addNode(agentNode, this.createCallModel(agentId))
       .addNode(
         toolNode,
         this.initializeTools({

package/src/messages/__tests__/tools.test.ts

@@ -0,0 +1,473 @@
+// src/messages/__tests__/tools.test.ts
+import {
+  AIMessageChunk,
+  ToolMessage,
+  HumanMessage,
+} from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { extractToolDiscoveries, hasToolSearchInCurrentTurn } from '../tools';
+import { Constants } from '@/common';
+
+describe('Tool Discovery Functions', () => {
+  /**
+   * Helper to create an AIMessageChunk with tool calls
+   */
+  const createAIMessage = (
+    content: string,
+    toolCalls: Array<{
+      id: string;
+      name: string;
+      args: Record<string, unknown>;
+    }>
+  ): AIMessageChunk => {
+    return new AIMessageChunk({
+      content,
+      tool_calls: toolCalls.map((tc) => ({
+        id: tc.id,
+        name: tc.name,
+        args: tc.args,
+        type: 'tool_call' as const,
+      })),
+    });
+  };
+
+  /**
+   * Helper to create a ToolMessage (tool search result)
+   */
+  const createToolSearchResult = (
+    toolCallId: string,
+    discoveredTools: string[]
+  ): ToolMessage => {
+    return new ToolMessage({
+      content: `Found ${discoveredTools.length} tools`,
+      tool_call_id: toolCallId,
+      name: Constants.TOOL_SEARCH_REGEX,
+      artifact: {
+        tool_references: discoveredTools.map((name) => ({
+          tool_name: name,
+          match_score: 0.9,
+          matched_field: 'description',
+          snippet: 'Test snippet',
+        })),
+        metadata: {
+          total_searched: 10,
+          pattern: 'test',
+        },
+      },
+    });
+  };
+
+  /**
+   * Helper to create a regular ToolMessage (non-search)
+   */
+  const createRegularToolMessage = (
+    toolCallId: string,
+    name: string,
+    content: string
+  ): ToolMessage => {
+    return new ToolMessage({
+      content,
+      tool_call_id: toolCallId,
+      name,
+    });
+  };
+
+  describe('extractToolDiscoveries', () => {
+    it('extracts tool names from a single tool search result', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search for database tools'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'database' },
+          },
+        ]),
+        createToolSearchResult('call_1', ['database_query', 'database_insert']),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual(['database_query', 'database_insert']);
+    });
+
+    it('extracts tool names from multiple tool search results in same turn', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search for tools'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'database' },
+          },
+          {
+            id: 'call_2',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'file' },
+          },
+        ]),
+        createToolSearchResult('call_1', ['database_query']),
+        createToolSearchResult('call_2', ['file_read', 'file_write']),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual(['database_query', 'file_read', 'file_write']);
+    });
+
+    it('returns empty array when no messages', () => {
+      const result = extractToolDiscoveries([]);
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when last message is not a ToolMessage', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Hello'),
+        createAIMessage('Hi there!', []),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when no AI message with tool calls found', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Hello'),
+        new ToolMessage({
+          content: 'Some result',
+          tool_call_id: 'orphan_call',
+          name: Constants.TOOL_SEARCH_REGEX,
+        }),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual([]);
+    });
+
+    it('ignores tool search results from previous turns', () => {
+      const messages: BaseMessage[] = [
+        // Turn 1: Previous search
+        new HumanMessage('Search for old tools'),
+        createAIMessage('Searching...', [
+          {
+            id: 'old_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'old' },
+          },
+        ]),
+        createToolSearchResult('old_call', ['old_tool_1', 'old_tool_2']),
+        // Turn 2: Current turn
+        new HumanMessage('Search for new tools'),
+        createAIMessage('Searching again...', [
+          {
+            id: 'new_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'new' },
+          },
+        ]),
+        createToolSearchResult('new_call', ['new_tool']),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      // Should only return tools from current turn
+      expect(result).toEqual(['new_tool']);
+    });
+
+    it('ignores non-search tool results', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Do some work'),
+        createAIMessage('Working...', [
+          {
+            id: 'search_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+          { id: 'other_call', name: 'get_weather', args: { city: 'NYC' } },
+        ]),
+        createToolSearchResult('search_call', ['found_tool']),
+        createRegularToolMessage('other_call', 'get_weather', '{"temp": 72}'),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual(['found_tool']);
+    });
+
+    it('handles empty tool_references in artifact', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'xyz' },
+          },
+        ]),
+        new ToolMessage({
+          content: 'No tools found',
+          tool_call_id: 'call_1',
+          name: Constants.TOOL_SEARCH_REGEX,
+          artifact: {
+            tool_references: [],
+            metadata: { total_searched: 10, pattern: 'xyz' },
+          },
+        }),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual([]);
+    });
+
+    it('handles missing artifact', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+        ]),
+        new ToolMessage({
+          content: 'Error occurred',
+          tool_call_id: 'call_1',
+          name: Constants.TOOL_SEARCH_REGEX,
+          // No artifact
+        }),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual([]);
+    });
+
+    it('ignores tool messages with wrong tool_call_id', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+        ]),
+        // This has a different tool_call_id that doesn't match the AI message
+        createToolSearchResult('wrong_id', ['should_not_appear']),
+        createToolSearchResult('call_1', ['correct_tool']),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      expect(result).toEqual(['correct_tool']);
+    });
+
+    it('only looks at messages after the latest AI parent', () => {
+      const messages: BaseMessage[] = [
+        // First AI message with search
+        createAIMessage('First search', [
+          {
+            id: 'first_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'first' },
+          },
+        ]),
+        createToolSearchResult('first_call', ['first_tool']),
+        // Second AI message - this is the "latest AI parent" for the last tool message
+        createAIMessage('Second search', [
+          {
+            id: 'second_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'second' },
+          },
+        ]),
+        createToolSearchResult('second_call', ['second_tool']),
+      ];
+
+      const result = extractToolDiscoveries(messages);
+
+      // Should only find second_tool (from the turn of the latest AI parent)
+      expect(result).toEqual(['second_tool']);
+    });
+  });
+
+  describe('hasToolSearchInCurrentTurn', () => {
+    it('returns true when current turn has tool search results', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+        ]),
+        createToolSearchResult('call_1', ['found_tool']),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(true);
+    });
+
+    it('returns false when no messages', () => {
+      const result = hasToolSearchInCurrentTurn([]);
+      expect(result).toBe(false);
+    });
+
+    it('returns false when last message is not a ToolMessage', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Hello'),
+        createAIMessage('Hi!', []),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when no AI parent found', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Hello'),
+        new ToolMessage({
+          content: 'Result',
+          tool_call_id: 'orphan',
+          name: Constants.TOOL_SEARCH_REGEX,
+        }),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when current turn has no tool search (only other tools)', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Get weather'),
+        createAIMessage('Getting weather...', [
+          { id: 'call_1', name: 'get_weather', args: { city: 'NYC' } },
+        ]),
+        createRegularToolMessage('call_1', 'get_weather', '{"temp": 72}'),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns true even with mixed tool types in current turn', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search and get weather'),
+        createAIMessage('Working...', [
+          {
+            id: 'search_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+          { id: 'weather_call', name: 'get_weather', args: { city: 'NYC' } },
+        ]),
+        createRegularToolMessage('weather_call', 'get_weather', '{"temp": 72}'),
+        createToolSearchResult('search_call', ['found_tool']),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(true);
+    });
+
+    it('returns false for tool search from previous turn', () => {
+      const messages: BaseMessage[] = [
+        // Previous turn with search
+        createAIMessage('Searching...', [
+          {
+            id: 'old_call',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'old' },
+          },
+        ]),
+        createToolSearchResult('old_call', ['old_tool']),
+        // Current turn without search
+        new HumanMessage('Get weather now'),
+        createAIMessage('Getting weather...', [
+          { id: 'weather_call', name: 'get_weather', args: { city: 'NYC' } },
+        ]),
+        createRegularToolMessage('weather_call', 'get_weather', '{"temp": 72}'),
+      ];
+
+      const result = hasToolSearchInCurrentTurn(messages);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('Integration: extractToolDiscoveries + hasToolSearchInCurrentTurn', () => {
+    it('hasToolSearchInCurrentTurn is true when extractToolDiscoveries returns results', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+        ]),
+        createToolSearchResult('call_1', ['tool_a', 'tool_b']),
+      ];
+
+      const hasSearch = hasToolSearchInCurrentTurn(messages);
+      const discoveries = extractToolDiscoveries(messages);
+
+      expect(hasSearch).toBe(true);
+      expect(discoveries.length).toBeGreaterThan(0);
+    });
+
+    it('both return empty/false for non-search turns', () => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Get weather'),
+        createAIMessage('Getting...', [
+          { id: 'call_1', name: 'get_weather', args: { city: 'NYC' } },
+        ]),
+        createRegularToolMessage('call_1', 'get_weather', '{"temp": 72}'),
+      ];
+
+      const hasSearch = hasToolSearchInCurrentTurn(messages);
+      const discoveries = extractToolDiscoveries(messages);
+
+      expect(hasSearch).toBe(false);
+      expect(discoveries).toEqual([]);
+    });
+
+    it('hasToolSearchInCurrentTurn can be used as quick check before extraction', () => {
+      const messagesWithSearch: BaseMessage[] = [
+        new HumanMessage('Search'),
+        createAIMessage('Searching...', [
+          {
+            id: 'call_1',
+            name: Constants.TOOL_SEARCH_REGEX,
+            args: { pattern: 'test' },
+          },
+        ]),
+        createToolSearchResult('call_1', ['tool_a']),
+      ];
+
+      const messagesWithoutSearch: BaseMessage[] = [
+        new HumanMessage('Hello'),
+        createAIMessage('Hi!', []),
+      ];
+
+      // Pattern: quick check first, then extract only if needed
+      if (hasToolSearchInCurrentTurn(messagesWithSearch)) {
+        const discoveries = extractToolDiscoveries(messagesWithSearch);
+        expect(discoveries).toEqual(['tool_a']);
+      }
+
+      if (hasToolSearchInCurrentTurn(messagesWithoutSearch)) {
+        // This should not execute
+        expect(true).toBe(false);
+      }
+    });
+  });
+});

package/src/messages/index.ts

@@ -4,3 +4,4 @@ export * from './prune';
 export * from './format';
 export * from './cache';
 export * from './content';
+export * from './tools';

package/src/messages/tools.ts

@@ -0,0 +1,99 @@
+// src/messages/toolDiscovery.ts
+import { AIMessageChunk, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { Constants } from '@/common';
+import { findLastIndex } from './core';
+
+type ToolSearchArtifact = {
+  tool_references?: Array<{ tool_name: string }>;
+};
+
+/**
+ * Extracts discovered tool names from tool search results in the current turn.
+ * Only processes tool search messages after the latest AI message with tool calls.
+ *
+ * Similar pattern to formatArtifactPayload - finds relevant messages efficiently
+ * by identifying the latest AI parent and only processing subsequent tool messages.
+ *
+ * @param messages - All messages in the conversation
+ * @returns Array of discovered tool names (empty if no new discoveries)
+ */
+export function extractToolDiscoveries(messages: BaseMessage[]): string[] {
+  const lastMessage = messages[messages.length - 1];
+  if (!(lastMessage instanceof ToolMessage)) return [];
+
+  // Find the latest AIMessage with tool_calls that this tool message belongs to
+  const latestAIParentIndex = findLastIndex(
+    messages,
+    (msg) =>
+      (msg instanceof AIMessageChunk &&
+        (msg.tool_calls?.length ?? 0) > 0 &&
+        msg.tool_calls?.some((tc) => tc.id === lastMessage.tool_call_id)) ??
+      false
+  );
+
+  if (latestAIParentIndex === -1) return [];
+
+  // Collect tool_call_ids from the AI message
+  const aiMessage = messages[latestAIParentIndex] as AIMessageChunk;
+  const toolCallIds = new Set(aiMessage.tool_calls?.map((tc) => tc.id) ?? []);
+
+  // Only process tool search results after the AI message that belong to this turn
+  const discoveredNames: string[] = [];
+  for (let i = latestAIParentIndex + 1; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!(msg instanceof ToolMessage)) continue;
+    if (msg.name !== Constants.TOOL_SEARCH_REGEX) continue;
+    if (!toolCallIds.has(msg.tool_call_id)) continue;
+
+    // This is a tool search result from the current turn
+    if (typeof msg.artifact === 'object' && msg.artifact != null) {
+      const artifact = msg.artifact as ToolSearchArtifact;
+      if (artifact.tool_references && artifact.tool_references.length > 0) {
+        for (const ref of artifact.tool_references) {
+          discoveredNames.push(ref.tool_name);
+        }
+      }
+    }
+  }
+
+  return discoveredNames;
+}
+
+/**
+ * Checks if the current turn has any tool search results.
+ * Quick check to avoid full extraction when not needed.
+ */
+export function hasToolSearchInCurrentTurn(messages: BaseMessage[]): boolean {
+  const lastMessage = messages[messages.length - 1];
+  if (!(lastMessage instanceof ToolMessage)) return false;
+
+  // Find the latest AIMessage with tool_calls
+  const latestAIParentIndex = findLastIndex(
+    messages,
+    (msg) =>
+      (msg instanceof AIMessageChunk &&
+        (msg.tool_calls?.length ?? 0) > 0 &&
+        msg.tool_calls?.some((tc) => tc.id === lastMessage.tool_call_id)) ??
+      false
+  );
+
+  if (latestAIParentIndex === -1) return false;
+
+  const aiMessage = messages[latestAIParentIndex] as AIMessageChunk;
+  const toolCallIds = new Set(aiMessage.tool_calls?.map((tc) => tc.id) ?? []);
+
+  // Check if any tool search results exist after the AI message
+  for (let i = latestAIParentIndex + 1; i < messages.length; i++) {
+    const msg = messages[i];
+    if (
+      msg instanceof ToolMessage &&
+      msg.name === Constants.TOOL_SEARCH_REGEX &&
+      toolCallIds.has(msg.tool_call_id)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}