@librechat/agents 3.0.42 → 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

@@ -35,7 +35,6 @@ import {
   GraphEvents,
   Providers,
   StepTypes,
-  Constants,
 } from '@/common';
 import {
   formatAnthropicArtifactContent,
@@ -47,6 +46,7 @@ import {
   formatContentStrings,
   createPruneMessages,
   addCacheControl,
+  extractToolDiscoveries,
 } from '@/messages';
 import {
   resetIfNotEmpty,
@@ -457,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(),
     });
   }
 
@@ -626,6 +624,14 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         throw new Error('No config provided');
       }
 
+      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 ??
@@ -646,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 (
@@ -712,23 +717,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
       const isLatestToolMessage = lastMessageY instanceof ToolMessage;
 
-      if (
-        isLatestToolMessage &&
-        lastMessageY.name === Constants.TOOL_SEARCH_REGEX &&
-        typeof lastMessageY.artifact === 'object' &&
-        lastMessageY.artifact != null
-      ) {
-        const artifact = lastMessageY.artifact as {
-          tool_references?: Array<{ tool_name: string }>;
-        };
-        if (artifact.tool_references && artifact.tool_references.length > 0) {
-          const discoveredNames = artifact.tool_references.map(
-            (ref) => ref.tool_name
-          );
-          agentContext.markToolsAsDiscovered(discoveredNames);
-        }
-      }
-
       if (
         isLatestToolMessage &&
         agentContext.provider === Providers.ANTHROPIC

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;
+}