@librechat/agents 3.2.65 → 3.2.67

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

@@ -360,6 +360,52 @@ describe('ToolSearch', () => {
       expect(result.tool_references[0].match_score).toBeGreaterThan(0);
     });
 
+    it('does not match tool names when searching only parameters', () => {
+      const tools: ToolMetadata[] = [
+        {
+          name: 'query',
+          description: 'A tool whose name matches but parameters do not',
+          parameters: {
+            type: 'object',
+            properties: { value: { type: 'string' } },
+          },
+        },
+        {
+          name: 'run_database_query',
+          description: 'Run a database query',
+          parameters: {
+            type: 'object',
+            properties: { query: { type: 'string' } },
+          },
+        },
+      ];
+
+      const result = performLocalSearch(tools, 'query', ['parameters'], 1);
+
+      expect(result.tool_references).toHaveLength(1);
+      expect(result.tool_references[0].tool_name).toBe('run_database_query');
+      expect(result.tool_references[0].matched_field).toBe('parameters');
+    });
+
+    it('returns no matches when every selected field is empty', () => {
+      const tools: ToolMetadata[] = [
+        {
+          name: 'get_weather',
+          description: 'Get the weather',
+          parameters: undefined,
+        },
+        {
+          name: 'send_email',
+          description: 'Send an email',
+          parameters: undefined,
+        },
+      ];
+
+      const result = performLocalSearch(tools, 'query', ['parameters'], 10);
+
+      expect(result.tool_references).toEqual([]);
+    });
+
     it('prioritizes name matches over description matches', () => {
       const result = performLocalSearch(
         mockTools,
@@ -830,6 +876,111 @@ describe('ToolSearch', () => {
       },
     ];
 
+    it('finds camelCase tools by exact name', () => {
+      const tools: ToolMetadata[] = [
+        {
+          name: 'addActivity',
+          description: 'Create an activity',
+          parameters: undefined,
+        },
+        {
+          name: 'addPerson',
+          description: 'Create a person',
+          parameters: undefined,
+        },
+      ];
+
+      const result = performLocalSearch(tools, 'addPerson', ['name'], 10);
+
+      expect(result.tool_references[0].tool_name).toBe('addPerson');
+      expect(result.tool_references[0].match_score).toBe(1.0);
+    });
+
+    it('finds camelCase tools by a lowercased exact name', () => {
+      const tools: ToolMetadata[] = [
+        {
+          name: 'addActivity',
+          description: 'Create an activity',
+          parameters: undefined,
+        },
+        {
+          name: 'addPerson',
+          description: 'Create a person',
+          parameters: undefined,
+        },
+      ];
+
+      const result = performLocalSearch(tools, 'addperson', ['name'], 10);
+
+      expect(result.tool_references).toHaveLength(1);
+      expect(result.tool_references[0].tool_name).toBe('addPerson');
+      expect(result.tool_references[0].match_score).toBe(1.0);
+    });
+
+    it('prioritizes an exact full camelCase MCP tool ID', () => {
+      const tools: ToolMetadata[] = [
+        {
+          name: 'add_person_mcp_pipedrive',
+          description: 'Create a person with a separator variant',
+          parameters: undefined,
+        },
+        {
+          name: 'addActivity_mcp_pipedrive',
+          description: 'Create an activity',
+          parameters: undefined,
+        },
+        {
+          name: 'addPerson_mcp_pipedrive',
+          description: 'Create a person',
+          parameters: undefined,
+        },
+        {
+          name: 'updatePerson_mcp_pipedrive',
+          description: 'Update a person',
+          parameters: undefined,
+        },
+      ];
+
+      const result = performLocalSearch(
+        tools,
+        'addPerson_mcp_pipedrive',
+        ['name'],
+        1
+      );
+
+      expect(result.tool_references[0].tool_name).toBe(
+        'addPerson_mcp_pipedrive'
+      );
+      expect(result.tool_references[0].match_score).toBe(1.0);
+    });
+
+    it.each([
+      ['OAuthToken', 'close_order'],
+      ['iOSApp', 'inspect_inventory'],
+    ])(
+      'does not return tools matching only an acronym fragment from %s',
+      (matchingTool, unrelatedTool) => {
+        const tools: ToolMetadata[] = [
+          {
+            name: matchingTool,
+            description: 'Expected acronym tool',
+            parameters: undefined,
+          },
+          {
+            name: unrelatedTool,
+            description: 'Unrelated tool',
+            parameters: undefined,
+          },
+        ];
+
+        const result = performLocalSearch(tools, matchingTool, ['name'], 10);
+
+        expect(
+          result.tool_references.map(({ tool_name }) => tool_name)
+        ).toEqual([matchingTool]);
+      }
+    );
+
     it('searches across all tools including MCP tools', () => {
       const result = performLocalSearch(
         mcpTools,

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

@@ -34,7 +34,7 @@ import type {
 import type * as t from '@/types';
 import { Providers as providers, GraphEvents } from '@/common';
 import * as events from '@/utils/events';
-import { HookRegistry } from '@/hooks';
+import { HookRegistry, createToolPolicyHook } from '@/hooks';
 import { ToolNode } from '../ToolNode';
 
 async function flushAsyncWork(): Promise<void> {
@@ -255,6 +255,119 @@ describe('ToolNode HITL — `ask` decision raises interrupt() when humanInTheLoo
     ]);
   });
 
+  it('waits for approval before executing an explicit ask rule in bypass mode', async () => {
+    let toolExecuted = false;
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data) => {
+        if (event !== 'on_tool_execute') {
+          return;
+        }
+        toolExecuted = true;
+        const request = data as {
+          resolve: (results: t.ToolExecuteResult[]) => void;
+        };
+        request.resolve([
+          { toolCallId: 'call_1', content: 'deleted', status: 'success' },
+        ]);
+      });
+    const registry = new HookRegistry();
+    registry.register('PreToolUse', {
+      hooks: [
+        createToolPolicyHook({
+          mode: 'bypass',
+          ask: ['dangerous_*'],
+        }),
+      ],
+    });
+    const node = new ToolNode({
+      tools: [createSchemaStub('dangerous_tool')],
+      eventDrivenMode: true,
+      agentId: 'agent-x',
+      toolCallStepIds: new Map([['call_1', 'step_call_1']]),
+      hookRegistry: registry,
+      humanInTheLoop: { enabled: true },
+    });
+    const graph = buildHITLGraph(node, [
+      {
+        id: 'call_1',
+        name: 'dangerous_tool',
+        args: { command: 'delete data' },
+      },
+    ]);
+    const config = {
+      configurable: { thread_id: 'thread-bypass-explicit-ask' },
+    };
+
+    const interrupted = await graph.invoke({ messages: [] }, config);
+
+    expect(isInterrupted<t.HumanInterruptPayload>(interrupted)).toBe(true);
+    expect(toolExecuted).toBe(false);
+
+    const resumed = (await resumeGraph(
+      graph,
+      interrupted,
+      [{ type: 'approve' }],
+      config
+    )) as { messages: BaseMessage[] };
+
+    expect(toolExecuted).toBe(true);
+    expect(
+      resumed.messages.some(
+        (message) =>
+          message._getType() === 'tool' &&
+          (message as ToolMessage).tool_call_id === 'call_1' &&
+          message.content === 'deleted'
+      )
+    ).toBe(true);
+  });
+
+  it('executes an unmatched tool without interruption in bypass mode', async () => {
+    let toolExecuted = false;
+    jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async (event, data) => {
+        if (event !== 'on_tool_execute') {
+          return;
+        }
+        toolExecuted = true;
+        const request = data as {
+          resolve: (results: t.ToolExecuteResult[]) => void;
+        };
+        request.resolve([
+          { toolCallId: 'call_1', content: 'read result', status: 'success' },
+        ]);
+      });
+    const registry = new HookRegistry();
+    registry.register('PreToolUse', {
+      hooks: [
+        createToolPolicyHook({
+          mode: 'bypass',
+          ask: ['dangerous_*'],
+        }),
+      ],
+    });
+    const node = new ToolNode({
+      tools: [createSchemaStub('read_tool')],
+      eventDrivenMode: true,
+      agentId: 'agent-x',
+      toolCallStepIds: new Map([['call_1', 'step_call_1']]),
+      hookRegistry: registry,
+      humanInTheLoop: { enabled: true },
+    });
+    const graph = buildHITLGraph(node, [
+      { id: 'call_1', name: 'read_tool', args: { command: 'read data' } },
+    ]);
+
+    const result = await graph.invoke(
+      { messages: [] },
+      { configurable: { thread_id: 'thread-bypass-unmatched' } }
+    );
+
+    expect(isInterrupted(result)).toBe(false);
+    expect(toolExecuted).toBe(true);
+  });
+
   it('resume with approve runs the tool through the host event path', async () => {
     mockEventDispatch([
       { toolCallId: 'call_1', content: 'host-result', status: 'success' },

package/src/tools/search/source-processing.test.ts

@@ -141,6 +141,63 @@ describe('expandHighlights content stripping', () => {
     expect(result.organic?.[0].content).toBeUndefined();
     expect(result.organic?.[0].references).toBeUndefined();
   });
+
+  test('honors a custom mainExpandBy when expanding highlights', () => {
+    const highlightText = 'KEYFACT';
+    // Boundary-free filler so expansion is governed purely by mainExpandBy,
+    // not by where natural separators happen to fall.
+    const content = `${'x'.repeat(1000)}${highlightText}${'y'.repeat(1000)}`;
+    const makeData = (): t.SearchResultData => ({
+      organic: [
+        {
+          ...makeOrganic('https://a.com'),
+          content,
+          highlights: [{ text: highlightText, score: 0.9 }],
+        },
+      ],
+    });
+
+    // separatorExpandBy 0 isolates the mainExpandBy effect.
+    const narrow = expandHighlights(makeData(), 50, 0).organic?.[0]
+      .highlights?.[0];
+    const wide = expandHighlights(makeData(), 500, 0).organic?.[0]
+      .highlights?.[0];
+
+    expect(narrow?.text).toContain(highlightText);
+    expect(wide?.text).toContain(highlightText);
+    // 50 chars of context each side vs. 500 → wide must be markedly longer.
+    expect(wide!.text.length).toBeGreaterThan(narrow!.text.length);
+    expect(narrow!.text.length).toBe(highlightText.length + 100);
+    expect(wide!.text.length).toBe(highlightText.length + 1000);
+  });
+
+  test('honors a custom separatorExpandBy when seeking boundaries', () => {
+    const highlightText = 'KEYFACT';
+    // The main window lands inside a boundary-free 'y' run; the only natural
+    // boundary ('. ') sits 250 chars past the main window's end. A small
+    // separator range can't reach it; a large one can.
+    const content = `${'x'.repeat(100)}${highlightText}${'y'.repeat(300)}. ${'z'.repeat(300)}`;
+    const makeData = (): t.SearchResultData => ({
+      organic: [
+        {
+          ...makeOrganic('https://a.com'),
+          content,
+          highlights: [{ text: highlightText, score: 0.9 }],
+        },
+      ],
+    });
+
+    // Same mainExpandBy; only the separator search range differs.
+    const narrow = expandHighlights(makeData(), 50, 100).organic?.[0]
+      .highlights?.[0];
+    const wide = expandHighlights(makeData(), 50, 400).organic?.[0]
+      .highlights?.[0];
+
+    expect(narrow?.text).toContain(highlightText);
+    expect(wide?.text).toContain(highlightText);
+    // Only the wider separator range reaches the trailing sentence boundary.
+    expect(wide!.text.length).toBeGreaterThan(narrow!.text.length);
+  });
 });
 
 describe('createSourceProcessor content capping', () => {

package/src/tools/search/tool.ts

@@ -203,6 +203,8 @@ function createSearchProcessor({
   supportsNews,
   sourceProcessor,
   onGetHighlights,
+  mainExpandBy,
+  separatorExpandBy,
   logger,
 }: {
   safeSearch: t.SearchToolConfig['safeSearch'];
@@ -212,6 +214,8 @@ function createSearchProcessor({
   searchAPI: ReturnType<typeof createSearchAPI>;
   sourceProcessor: ReturnType<typeof createSourceProcessor>;
   onGetHighlights: t.SearchToolConfig['onGetHighlights'];
+  mainExpandBy: t.SearchToolConfig['mainExpandBy'];
+  separatorExpandBy: t.SearchToolConfig['separatorExpandBy'];
   logger: t.Logger;
 }) {
   return async function ({
@@ -260,7 +264,11 @@ function createSearchProcessor({
         numElements: maxSources,
       });
 
-      return expandHighlights(processedSources);
+      return expandHighlights(
+        processedSources,
+        mainExpandBy,
+        separatorExpandBy
+      );
     } catch (error) {
       logger.error('Error in search:', error);
       return {
@@ -376,6 +384,8 @@ export const createSearchTool = (
     maxContentLength,
     chunkSize,
     chunkOverlap,
+    mainExpandBy,
+    separatorExpandBy,
     maxOutputChars,
     strategies = ['no_extraction'],
     filterContent = true,
@@ -525,6 +535,8 @@ export const createSearchTool = (
     supportsNews: searchProvider !== 'keenable',
     sourceProcessor,
     onGetHighlights,
+    mainExpandBy,
+    separatorExpandBy,
     logger,
   });
 

package/src/tools/search/types.ts

@@ -227,6 +227,8 @@ export interface ProcessSourcesConfig {
    * configurable via the `SEARCH_CHUNK_OVERLAP` env var. Clamped below
    * `chunkSize`. */
   chunkOverlap?: number;
+  mainExpandBy?: number;
+  separatorExpandBy?: number;
   strategies?: string[];
   filterContent?: boolean;
   reranker?: BaseReranker;

package/src/types/graph.ts

@@ -534,9 +534,9 @@ export type LangfuseToolOutputTracingConfig = {
 
 export type LangfuseToolNodeTracingConfig = {
   /**
-   * Overrides ToolNode callback tracing. ToolNode spans are exported by the
-   * env-backed Langfuse callback, so this only enables tracing when that
-   * callback is configured.
+   * Opts into the internal ToolNode batch observation. Graph tool-dispatch
+   * and individual tool observations are exported without this wrapper, so
+   * the default is false to avoid a redundant hierarchy level.
    */
   enabled?: boolean;
 };
@@ -546,6 +546,13 @@ export interface LangfuseConfig {
   publicKey?: string;
   secretKey?: string;
   baseUrl?: string;
+  /**
+   * Environment identifier attached to exported traces (Langfuse
+   * `environment`). When unset, falls back to `LANGFUSE_TRACING_ENVIRONMENT`
+   * then `NODE_ENV`, so production traces are not collapsed under the
+   * `default` environment.
+   */
+  environment?: string;
   metadata?: Record<string, string | number | boolean | null | undefined>;
   /**
    * Internal OTLP span attributes to attach to Langfuse observations before