@librechat/agents 3.0.66 → 3.0.67

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

@@ -41,7 +41,7 @@ describe('Tool Discovery Functions', () => {
     return new ToolMessage({
       content: `Found ${discoveredTools.length} tools`,
       tool_call_id: toolCallId,
-      name: Constants.TOOL_SEARCH_REGEX,
+      name: Constants.TOOL_SEARCH,
       artifact: {
         tool_references: discoveredTools.map((name) => ({
           tool_name: name,
@@ -79,7 +79,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'database' },
           },
         ]),
@@ -97,12 +97,12 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'database' },
           },
           {
             id: 'call_2',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'file' },
           },
         ]),
@@ -137,7 +137,7 @@ describe('Tool Discovery Functions', () => {
         new ToolMessage({
           content: 'Some result',
           tool_call_id: 'orphan_call',
-          name: Constants.TOOL_SEARCH_REGEX,
+          name: Constants.TOOL_SEARCH,
         }),
       ];
 
@@ -153,7 +153,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'old_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'old' },
           },
         ]),
@@ -163,7 +163,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching again...', [
           {
             id: 'new_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'new' },
           },
         ]),
@@ -182,7 +182,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Working...', [
           {
             id: 'search_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
           { id: 'other_call', name: 'get_weather', args: { city: 'NYC' } },
@@ -202,14 +202,14 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'xyz' },
           },
         ]),
         new ToolMessage({
           content: 'No tools found',
           tool_call_id: 'call_1',
-          name: Constants.TOOL_SEARCH_REGEX,
+          name: Constants.TOOL_SEARCH,
           artifact: {
             tool_references: [],
             metadata: { total_searched: 10, pattern: 'xyz' },
@@ -228,14 +228,14 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
         ]),
         new ToolMessage({
           content: 'Error occurred',
           tool_call_id: 'call_1',
-          name: Constants.TOOL_SEARCH_REGEX,
+          name: Constants.TOOL_SEARCH,
           // No artifact
         }),
       ];
@@ -251,7 +251,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
         ]),
@@ -271,7 +271,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('First search', [
           {
             id: 'first_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'first' },
           },
         ]),
@@ -280,7 +280,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Second search', [
           {
             id: 'second_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'second' },
           },
         ]),
@@ -301,7 +301,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
         ]),
@@ -335,7 +335,7 @@ describe('Tool Discovery Functions', () => {
         new ToolMessage({
           content: 'Result',
           tool_call_id: 'orphan',
-          name: Constants.TOOL_SEARCH_REGEX,
+          name: Constants.TOOL_SEARCH,
         }),
       ];
 
@@ -364,7 +364,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Working...', [
           {
             id: 'search_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
           { id: 'weather_call', name: 'get_weather', args: { city: 'NYC' } },
@@ -384,7 +384,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'old_call',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'old' },
           },
         ]),
@@ -410,7 +410,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
         ]),
@@ -446,7 +446,7 @@ describe('Tool Discovery Functions', () => {
         createAIMessage('Searching...', [
           {
             id: 'call_1',
-            name: Constants.TOOL_SEARCH_REGEX,
+            name: Constants.TOOL_SEARCH,
             args: { pattern: 'test' },
           },
         ]),

package/src/messages/tools.ts

@@ -43,7 +43,7 @@ export function extractToolDiscoveries(messages: BaseMessage[]): 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 (msg.name !== Constants.TOOL_SEARCH) continue;
     if (!toolCallIds.has(msg.tool_call_id)) continue;
 
     // This is a tool search result from the current turn
@@ -88,7 +88,7 @@ export function hasToolSearchInCurrentTurn(messages: BaseMessage[]): boolean {
     const msg = messages[i];
     if (
       msg instanceof ToolMessage &&
-      msg.name === Constants.TOOL_SEARCH_REGEX &&
+      msg.name === Constants.TOOL_SEARCH &&
       toolCallIds.has(msg.tool_call_id)
     ) {
       return true;

package/src/scripts/programmatic_exec_agent.ts

@@ -23,7 +23,7 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import { createCodeExecutionTool } from '@/tools/CodeExecutor';
 import { createProgrammaticToolCallingTool } from '@/tools/ProgrammaticToolCalling';
-import { createToolSearchRegexTool } from '@/tools/ToolSearchRegex';
+import { createToolSearch } from '@/tools/ToolSearch';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
@@ -40,7 +40,7 @@ import {
 
 /**
  * Tool registry only needs business logic tools that require filtering.
- * Special tools (execute_code, run_tools_with_code, tool_search_regex)
+ * Special tools (execute_code, run_tools_with_code, tool_search)
  * are always bound directly to the LLM and don't need registry entries.
  */
 function createAgentToolRegistry(): t.LCToolRegistry {
@@ -73,7 +73,7 @@ async function main(): Promise<void> {
   // Create special tools (PTC, code execution, tool search)
   const codeExecTool = createCodeExecutionTool();
   const ptcTool = createProgrammaticToolCallingTool();
-  const toolSearchTool = createToolSearchRegexTool();
+  const toolSearchTool = createToolSearch();
 
   // Build complete tool list and map
   const allTools = [...mockTools, codeExecTool, ptcTool, toolSearchTool];
@@ -199,7 +199,7 @@ Use the run_tools_with_code tool to do this efficiently - don't call each tool s
   console.log('='.repeat(70));
   console.log('\nKey observations:');
   console.log(
-    '1. LLM only sees tools with allowed_callers including "direct" (get_weather, execute_code, run_tools_with_code, tool_search_regex)'
+    '1. LLM only sees tools with allowed_callers including "direct" (get_weather, execute_code, run_tools_with_code, tool_search)'
   );
   console.log(
     '2. When PTC is invoked, ToolNode automatically injects programmatic tools (get_team_members, get_expenses, get_weather)'

package/src/scripts/{tool_search_regex.ts → tool_search.ts}

@@ -1,7 +1,7 @@
-// src/scripts/tool_search_regex.ts
+// src/scripts/tool_search.ts
 /**
  * Test script for the Tool Search Regex tool.
- * Run with: npm run tool_search_regex
+ * Run with: npm run tool_search
  *
  * Demonstrates runtime registry injection - the tool registry is passed
  * at invocation time, not at initialization time.
@@ -9,7 +9,7 @@
 import { config } from 'dotenv';
 config();
 
-import { createToolSearchRegexTool } from '@/tools/ToolSearchRegex';
+import { createToolSearch } from '@/tools/ToolSearch';
 import type { LCToolRegistry } from '@/types';
 import { createToolSearchToolRegistry } from '@/test/mockTools';
 
@@ -22,7 +22,7 @@ interface RunTestOptions {
 }
 
 async function runTest(
-  searchTool: ReturnType<typeof createToolSearchRegexTool>,
+  searchTool: ReturnType<typeof createToolSearch>,
   testName: string,
   query: string,
   options: RunTestOptions
@@ -82,7 +82,7 @@ async function main(): Promise<void> {
   );
 
   console.log('\nCreating Tool Search Regex tool WITH registry for testing...');
-  const searchTool = createToolSearchRegexTool({ apiKey, toolRegistry });
+  const searchTool = createToolSearch({ apiKey, toolRegistry });
   console.log('Tool created successfully!');
   console.log(
     'Note: In production, ToolNode injects toolRegistry via params when invoked through the graph.\n'

package/src/tools/ToolNode.ts

@@ -132,7 +132,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           toolMap,
           toolDefs,
         };
-      } else if (call.name === Constants.TOOL_SEARCH_REGEX) {
+      } else if (call.name === Constants.TOOL_SEARCH) {
         invokeParams = {
           ...invokeParams,
           toolRegistry: this.toolRegistry,

package/src/tools/{ToolSearchRegex.ts → ToolSearch.ts}

@@ -1,4 +1,4 @@
-// src/tools/ToolSearchRegex.ts
+// src/tools/ToolSearch.ts
 import { z } from 'zod';
 import { config } from 'dotenv';
 import fetch, { RequestInit } from 'node-fetch';
@@ -20,28 +20,43 @@ const MAX_REGEX_COMPLEXITY = 5;
 /** Default search timeout in milliseconds */
 const SEARCH_TIMEOUT = 5000;
 
-const ToolSearchRegexSchema = z.object({
-  query: z
-    .string()
-    .min(1)
-    .max(MAX_PATTERN_LENGTH)
-    .describe(
-      'Regex pattern to search tool names and descriptions. Special regex characters will be sanitized for safety.'
-    ),
-  fields: z
-    .array(z.enum(['name', 'description', 'parameters']))
-    .optional()
-    .default(['name', 'description'])
-    .describe('Which fields to search. Default: name and description'),
-  max_results: z
-    .number()
-    .int()
-    .min(1)
-    .max(50)
-    .optional()
-    .default(10)
-    .describe('Maximum number of matching tools to return'),
-});
+/** Zod schema type for tool search parameters */
+type ToolSearchSchema = z.ZodObject<{
+  query: z.ZodString;
+  fields: z.ZodDefault<
+    z.ZodOptional<z.ZodArray<z.ZodEnum<['name', 'description', 'parameters']>>>
+  >;
+  max_results: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}>;
+
+/**
+ * Creates the Zod schema with dynamic query description based on mode.
+ * @param mode - The search mode determining query interpretation
+ * @returns Zod schema for tool search parameters
+ */
+function createToolSearchSchema(mode: t.ToolSearchMode): ToolSearchSchema {
+  const queryDescription =
+    mode === 'local'
+      ? 'Search term to find in tool names and descriptions. Case-insensitive substring matching.'
+      : 'Regex pattern to search tool names and descriptions. Special regex characters will be sanitized for safety.';
+
+  return z.object({
+    query: z.string().min(1).max(MAX_PATTERN_LENGTH).describe(queryDescription),
+    fields: z
+      .array(z.enum(['name', 'description', 'parameters']))
+      .optional()
+      .default(['name', 'description'])
+      .describe('Which fields to search. Default: name and description'),
+    max_results: z
+      .number()
+      .int()
+      .min(1)
+      .max(50)
+      .optional()
+      .default(10)
+      .describe('Maximum number of matching tools to return'),
+  });
+}
 
 /**
  * Escapes special regex characters in a string to use as a literal pattern.
@@ -170,6 +185,80 @@ function simplifyParametersForSearch(
   return { type: parameters.type };
 }
 
+/**
+ * Performs safe local substring search without regex.
+ * Uses case-insensitive String.includes() for complete safety against ReDoS.
+ * @param tools - Array of tool metadata to search
+ * @param query - The search term (treated as literal substring)
+ * @param fields - Which fields to search
+ * @param maxResults - Maximum results to return
+ * @returns Search response with matching tools
+ */
+function performLocalSearch(
+  tools: t.ToolMetadata[],
+  query: string,
+  fields: string[],
+  maxResults: number
+): t.ToolSearchResponse {
+  const lowerQuery = query.toLowerCase();
+  const results: t.ToolSearchResult[] = [];
+
+  for (const tool of tools) {
+    let bestScore = 0;
+    let matchedField = '';
+    let snippet = '';
+
+    if (fields.includes('name')) {
+      const lowerName = tool.name.toLowerCase();
+      if (lowerName.includes(lowerQuery)) {
+        const isExactMatch = lowerName === lowerQuery;
+        const startsWithQuery = lowerName.startsWith(lowerQuery);
+        bestScore = isExactMatch ? 1.0 : startsWithQuery ? 0.95 : 0.85;
+        matchedField = 'name';
+        snippet = tool.name;
+      }
+    }
+
+    if (fields.includes('description') && tool.description) {
+      const lowerDesc = tool.description.toLowerCase();
+      if (lowerDesc.includes(lowerQuery) && bestScore === 0) {
+        bestScore = 0.7;
+        matchedField = 'description';
+        snippet = tool.description.substring(0, 100);
+      }
+    }
+
+    if (fields.includes('parameters') && tool.parameters?.properties) {
+      const paramNames = Object.keys(tool.parameters.properties)
+        .join(' ')
+        .toLowerCase();
+      if (paramNames.includes(lowerQuery) && bestScore === 0) {
+        bestScore = 0.55;
+        matchedField = 'parameters';
+        snippet = Object.keys(tool.parameters.properties).join(' ');
+      }
+    }
+
+    if (bestScore > 0) {
+      results.push({
+        tool_name: tool.name,
+        match_score: bestScore,
+        matched_field: matchedField,
+        snippet,
+      });
+    }
+  }
+
+  results.sort((a, b) => b.match_score - a.match_score);
+  const topResults = results.slice(0, maxResults);
+
+  return {
+    tool_references: topResults,
+    total_tools_searched: tools.length,
+    pattern_used: query,
+  };
+}
+
 /**
  * Generates the JavaScript search script to be executed in the sandbox.
  * Uses plain JavaScript for maximum compatibility with the Code API.
@@ -307,11 +396,15 @@ function formatSearchResults(searchResponse: t.ToolSearchResponse): string {
 }
 
 /**
- * Creates a Tool Search Regex tool for discovering tools from a large registry.
+ * Creates a Tool Search tool for discovering tools from a large registry.
  *
  * This tool enables AI agents to dynamically discover tools from a large library
  * without loading all tool definitions into the LLM context window. The agent
- * can search for relevant tools on-demand using regex patterns.
+ * can search for relevant tools on-demand.
+ *
+ * **Modes:**
+ * - `code_interpreter` (default): Uses external sandbox for regex search. Safer for complex patterns.
+ * - `local`: Uses safe substring matching locally. No network call, faster, completely safe from ReDoS.
  *
  * The tool registry can be provided either:
  * 1. At initialization time via params.toolRegistry
@@ -321,36 +414,52 @@ function formatSearchResults(searchResponse: t.ToolSearchResponse): string {
  * @returns A LangChain DynamicStructuredTool for tool searching
  *
  * @example
- * // Option 1: Registry at initialization
- * const tool = createToolSearchRegexTool({ apiKey, toolRegistry });
- * await tool.invoke({ query: 'expense' });
+ * // Option 1: Code interpreter mode (regex via sandbox)
+ * const tool = createToolSearch({ apiKey, toolRegistry });
+ * await tool.invoke({ query: 'expense.*report' });
  *
  * @example
- * // Option 2: Registry at runtime
- * const tool = createToolSearchRegexTool({ apiKey });
- * await tool.invoke(
- *   { query: 'expense' },
- *   { configurable: { toolRegistry, onlyDeferred: true } }
- * );
+ * // Option 2: Local mode (safe substring search, no API key needed)
+ * const tool = createToolSearch({ mode: 'local', toolRegistry });
+ * await tool.invoke({ query: 'expense' });
  */
-function createToolSearchRegexTool(
-  initParams: t.ToolSearchRegexParams = {}
-): DynamicStructuredTool<typeof ToolSearchRegexSchema> {
-  const apiKey: string =
-    (initParams[EnvVar.CODE_API_KEY] as string | undefined) ??
-    initParams.apiKey ??
-    getEnvironmentVariable(EnvVar.CODE_API_KEY) ??
-    '';
+function createToolSearch(
+  initParams: t.ToolSearchParams = {}
+): DynamicStructuredTool<ReturnType<typeof createToolSearchSchema>> {
+  const mode: t.ToolSearchMode = initParams.mode ?? 'code_interpreter';
+  const defaultOnlyDeferred = initParams.onlyDeferred ?? true;
+  const schema = createToolSearchSchema(mode);
 
-  if (!apiKey) {
-    throw new Error('No API key provided for tool search regex tool.');
+  const apiKey: string =
+    mode === 'code_interpreter'
+      ? ((initParams[EnvVar.CODE_API_KEY] as string | undefined) ??
+        initParams.apiKey ??
+        getEnvironmentVariable(EnvVar.CODE_API_KEY) ??
+        '')
+      : '';
+
+  if (mode === 'code_interpreter' && !apiKey) {
+    throw new Error(
+      'No API key provided for tool search in code_interpreter mode. Use mode: "local" to search without an API key.'
+    );
   }
 
   const baseEndpoint = initParams.baseUrl ?? getCodeBaseURL();
   const EXEC_ENDPOINT = `${baseEndpoint}/exec`;
-  const defaultOnlyDeferred = initParams.onlyDeferred ?? true;
 
-  const description = `
+  const description =
+    mode === 'local'
+      ? `
+Searches through available tools to find ones matching your search term.
+
+Usage:
+- Provide a search term to find in tool names and descriptions.
+- Uses case-insensitive substring matching (fast and safe).
+- Use this when you need to discover tools for a specific task.
+- Results include tool names, match quality scores, and snippets showing where the match occurred.
+- Higher scores (0.95+) indicate name matches, medium scores (0.70+) indicate description matches.
+`.trim()
+      : `
 Searches through available tools to find ones matching your query pattern.
 
 Usage:
@@ -360,7 +469,7 @@ Usage:
 - Higher scores (0.9+) indicate name matches, medium scores (0.7+) indicate description matches.
 `.trim();
 
-  return tool<typeof ToolSearchRegexSchema>(
+  return tool<typeof schema>(
     async (params, config) => {
       const {
         query,
@@ -368,21 +477,11 @@ Usage:
         max_results = 10,
       } = params;
 
-      // Extra params injected by ToolNode (follows web_search pattern)
       const {
         toolRegistry: paramToolRegistry,
         onlyDeferred: paramOnlyDeferred,
       } = config.toolCall ?? {};
 
-      const { safe: sanitizedPattern, wasEscaped } = sanitizeRegex(query);
-
-      let warningMessage = '';
-      if (wasEscaped) {
-        warningMessage =
-          'Note: The provided pattern was converted to a literal search for safety.\n\n';
-      }
-
-      // Priority: ToolNode injection (via config.toolCall) > initialization params
       const toolRegistry = paramToolRegistry ?? initParams.toolRegistry;
       const onlyDeferred =
         paramOnlyDeferred !== undefined
@@ -391,12 +490,12 @@ Usage:
 
       if (toolRegistry == null) {
         return [
-          `${warningMessage}Error: No tool registry provided. Configure toolRegistry at agent level or initialization.`,
+          'Error: No tool registry provided. Configure toolRegistry at agent level or initialization.',
           {
             tool_references: [],
             metadata: {
               total_searched: 0,
-              pattern: sanitizedPattern,
+              pattern: query,
               error: 'No tool registry provided',
             },
           },
@@ -404,14 +503,10 @@ Usage:
       }
 
       const toolsArray: t.LCTool[] = Array.from(toolRegistry.values());
-
       const deferredTools: t.ToolMetadata[] = toolsArray
-        .filter((lcTool) => {
-          if (onlyDeferred === true) {
-            return lcTool.defer_loading === true;
-          }
-          return true;
-        })
+        .filter((lcTool) =>
+          onlyDeferred === true ? lcTool.defer_loading === true : true
+        )
         .map((lcTool) => ({
           name: lcTool.name,
           description: lcTool.description ?? '',
@@ -420,17 +515,42 @@ Usage:
 
       if (deferredTools.length === 0) {
         return [
-          `${warningMessage}No tools available to search. The tool registry is empty or no deferred tools are registered.`,
+          'No tools available to search. The tool registry is empty or no deferred tools are registered.',
           {
             tool_references: [],
+            metadata: { total_searched: 0, pattern: query },
+          },
+        ];
+      }
+
+      if (mode === 'local') {
+        const searchResponse = performLocalSearch(
+          deferredTools,
+          query,
+          fields,
+          max_results
+        );
+        const formattedOutput = formatSearchResults(searchResponse);
+
+        return [
+          formattedOutput,
+          {
+            tool_references: searchResponse.tool_references,
             metadata: {
-              total_searched: 0,
-              pattern: sanitizedPattern,
+              total_searched: searchResponse.total_tools_searched,
+              pattern: searchResponse.pattern_used,
             },
           },
         ];
       }
 
+      const { safe: sanitizedPattern, wasEscaped } = sanitizeRegex(query);
+      let warningMessage = '';
+      if (wasEscaped) {
+        warningMessage =
+          'Note: The provided pattern was converted to a literal search for safety.\n\n';
+      }
+
       const searchScript = generateSearchScript(
         deferredTools,
         fields,
@@ -468,7 +588,7 @@ Usage:
 
         if (result.stderr && result.stderr.trim()) {
           // eslint-disable-next-line no-console
-          console.warn('[ToolSearchRegex] stderr:', result.stderr);
+          console.warn('[ToolSearch] stderr:', result.stderr);
         }
 
         if (!result.stdout || !result.stdout.trim()) {
@@ -499,7 +619,7 @@ Usage:
         ];
       } catch (error) {
         // eslint-disable-next-line no-console
-        console.error('[ToolSearchRegex] Error:', error);
+        console.error('[ToolSearch] Error:', error);
 
         const errorMessage =
           error instanceof Error ? error.message : String(error);
@@ -517,16 +637,17 @@ Usage:
       }
     },
     {
-      name: Constants.TOOL_SEARCH_REGEX,
+      name: Constants.TOOL_SEARCH,
       description,
-      schema: ToolSearchRegexSchema,
+      schema,
       responseFormat: Constants.CONTENT_AND_ARTIFACT,
     }
   );
 }
 
 export {
-  createToolSearchRegexTool,
+  createToolSearch,
+  performLocalSearch,
   sanitizeRegex,
   escapeRegexSpecialChars,
   isDangerousPattern,