illuma-agents 1.0.9 → 1.0.11

package/src/scripts/tool_search_regex.ts

@@ -0,0 +1,162 @@
+// src/scripts/tool_search_regex.ts
+/**
+ * Test script for the Tool Search Regex tool.
+ * Run with: npm run tool_search_regex
+ *
+ * Demonstrates runtime registry injection - the tool registry is passed
+ * at invocation time, not at initialization time.
+ */
+import { config } from 'dotenv';
+config();
+
+import { createToolSearchRegexTool } from '@/tools/ToolSearchRegex';
+import type { LCToolRegistry } from '@/types';
+import { createToolSearchToolRegistry } from '@/test/mockTools';
+
+interface RunTestOptions {
+  fields?: ('name' | 'description' | 'parameters')[];
+  max_results?: number;
+  showArtifact?: boolean;
+  toolRegistry: LCToolRegistry;
+  onlyDeferred?: boolean;
+}
+
+async function runTest(
+  searchTool: ReturnType<typeof createToolSearchRegexTool>,
+  testName: string,
+  query: string,
+  options: RunTestOptions
+): Promise<void> {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`TEST: ${testName}`);
+  console.log(`Query: "${query}"`);
+  if (options.fields) console.log(`Fields: ${options.fields.join(', ')}`);
+  if (options.max_results) console.log(`Max Results: ${options.max_results}`);
+  console.log('='.repeat(60));
+
+  try {
+    const startTime = Date.now();
+
+    // Manual testing uses schema params directly
+    // (ToolNode uses different param structure when injecting)
+    const result = await searchTool.invoke({
+      query,
+      fields: options.fields,
+      max_results: options.max_results,
+    });
+    const duration = Date.now() - startTime;
+
+    console.log(`\nResult (${duration}ms):`);
+    if (Array.isArray(result)) {
+      console.log(result[0]);
+      if (options.showArtifact) {
+        console.log('\n--- Artifact ---');
+        console.dir(result[1], { depth: null });
+      }
+    } else {
+      console.log(result);
+    }
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : error);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('Tool Search Regex - Test Script');
+  console.log('================================');
+  console.log('Demonstrating runtime tool registry injection\n');
+
+  const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
+  if (!apiKey) {
+    console.error(
+      'Error: LIBRECHAT_CODE_API_KEY environment variable is not set.'
+    );
+    console.log('Please set it in your .env file or environment.');
+    process.exit(1);
+  }
+
+  console.log('Creating sample tool registry...');
+  const toolRegistry = createToolSearchToolRegistry();
+  console.log(
+    `Registry contains ${toolRegistry.size} tools (${Array.from(toolRegistry.values()).filter((t) => t.defer_loading).length} deferred)`
+  );
+
+  console.log('\nCreating Tool Search Regex tool WITH registry for testing...');
+  const searchTool = createToolSearchRegexTool({ apiKey, toolRegistry });
+  console.log('Tool created successfully!');
+  console.log(
+    'Note: In production, ToolNode injects toolRegistry via params when invoked through the graph.\n'
+  );
+
+  const baseOptions = { toolRegistry, onlyDeferred: true };
+
+  // Test 1: Simple keyword search (with artifact display)
+  await runTest(searchTool, 'Simple keyword search', 'expense', {
+    ...baseOptions,
+    showArtifact: true,
+  });
+
+  // Test 2: Search for weather-related tools
+  await runTest(searchTool, 'Weather tools', 'weather|forecast', baseOptions);
+
+  // Test 3: Search with case variations
+  await runTest(searchTool, 'Case insensitive search', 'EMAIL', baseOptions);
+
+  // Test 4: Search in description only
+  await runTest(searchTool, 'Description-only search', 'database', {
+    ...baseOptions,
+    fields: ['description'],
+  });
+
+  // Test 5: Search with parameters field
+  await runTest(searchTool, 'Parameters search', 'query', {
+    ...baseOptions,
+    fields: ['parameters'],
+  });
+
+  // Test 6: Limited results
+  await runTest(searchTool, 'Limited to 2 results', 'get', {
+    ...baseOptions,
+    max_results: 2,
+  });
+
+  // Test 7: Pattern that matches nothing
+  await runTest(searchTool, 'No matches', 'xyznonexistent123', baseOptions);
+
+  // Test 8: Regex pattern with character class
+  await runTest(
+    searchTool,
+    'Regex with character class',
+    'get_[a-z]+',
+    baseOptions
+  );
+
+  // Test 9: Dangerous pattern (should be sanitized)
+  await runTest(
+    searchTool,
+    'Dangerous pattern (sanitized)',
+    '(a+)+',
+    baseOptions
+  );
+
+  // Test 10: Search all fields
+  await runTest(searchTool, 'All fields search', 'text', {
+    ...baseOptions,
+    fields: ['name', 'description', 'parameters'],
+  });
+
+  // Test 11: Search ALL tools (not just deferred)
+  await runTest(searchTool, 'Search ALL tools (incl. non-deferred)', 'calc', {
+    toolRegistry,
+    onlyDeferred: false, // Include non-deferred tools
+  });
+
+  console.log('\n' + '='.repeat(60));
+  console.log('All tests completed!');
+  console.log('='.repeat(60) + '\n');
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/src/specs/thinking-prune.test.ts

@@ -1,11 +1,5 @@
 // src/specs/thinking-prune.test.ts
-import {
-  HumanMessage,
-  AIMessage,
-  SystemMessage,
-  BaseMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
+import { HumanMessage, AIMessage, SystemMessage, BaseMessage, ToolMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { createPruneMessages } from '@/messages/prune';
 
@@ -13,10 +7,7 @@ import { createPruneMessages } from '@/messages/prune';
 const createTestTokenCounter = (): t.TokenCounter => {
   return (message: BaseMessage): number => {
     // Use type assertion to help TypeScript understand the type
-    const content = message.content as
-      | string
-      | Array<t.MessageContentComplex | string>
-      | undefined;
+    const content = message.content as string | Array<t.MessageContentComplex | string> | undefined;
 
     // Handle string content
     if (typeof content === 'string') {
@@ -61,7 +52,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
       content: [
         {
           type: 'text',
-          text: '/home/danny/Illuma/gistfile1.txt\n\nread it 200 lines at a time\n\nthere are 5000 lines\n\ndo not stop until done',
+          text: '/home/danny/LibreChat/gistfile1.txt\n\nread it 200 lines at a time\n\nthere are 5000 lines\n\ndo not stop until done',
         },
       ],
     });
@@ -70,8 +61,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
       content: [
         {
           type: 'thinking',
-          thinking:
-            'The user is asking me to read a file located at `/home/danny/Illuma/gistfile1.txt` in chunks of 200 lines at a time, mentioning that the file has 5000 lines total. They want me to continue reading through the entire file without stopping.\n\nI\'ll need to use the text editor tool to view the file in chunks of 200 lines each. Since the file has 5000 lines, I\'ll need to view it in 25 chunks (5000 ÷ 200 = 25).\n\nI\'ll need to make multiple calls to the text editor with the `view` command, specifying different line ranges for each call.\n\nLet me plan out the approach:\n1. Start with lines 1-200\n2. Then 201-400\n3. Then 401-600\n4. And so on until I reach 4801-5000\n\nFor each call, I\'ll use the `view` command with the specific line range in the `view_range` parameter. I\'ll continue until I\'ve shown all 5000 lines as requested.',
+          thinking: 'The user is asking me to read a file located at `/home/danny/LibreChat/gistfile1.txt` in chunks of 200 lines at a time, mentioning that the file has 5000 lines total. They want me to continue reading through the entire file without stopping.\n\nI\'ll need to use the text editor tool to view the file in chunks of 200 lines each. Since the file has 5000 lines, I\'ll need to view it in 25 chunks (5000 ÷ 200 = 25).\n\nI\'ll need to make multiple calls to the text editor with the `view` command, specifying different line ranges for each call.\n\nLet me plan out the approach:\n1. Start with lines 1-200\n2. Then 201-400\n3. Then 401-600\n4. And so on until I reach 4801-5000\n\nFor each call, I\'ll use the `view` command with the specific line range in the `view_range` parameter. I\'ll continue until I\'ve shown all 5000 lines as requested.',
         },
         {
           type: 'text',
@@ -81,8 +71,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
           type: 'tool_use',
           id: 'toolu_01YApWuFsEQCuBFDgYXmcmeZ',
           name: 'text_editor_mcp_textEditor',
-          input:
-            '{"command": "view", "path": "/home/danny/Illuma/gistfile1.txt", "description": "Viewing lines 1-200 of the file", "view_range": [1,200]}',
+          input: '{"command": "view", "path": "/home/danny/LibreChat/gistfile1.txt", "description": "Viewing lines 1-200 of the file", "view_range": [1,200]}',
         },
       ],
     });
@@ -108,8 +97,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
           type: 'tool_use',
           id: 'toolu_01VnyMQ4CvEd6zLDxxtTd6d4',
           name: 'text_editor_mcp_textEditor',
-          input:
-            '{"command": "view", "path": "/home/danny/Illuma/gistfile1.txt", "description": "Viewing lines 201-400 of the file", "view_range": [201,400]}',
+          input: '{"command": "view", "path": "/home/danny/LibreChat/gistfile1.txt", "description": "Viewing lines 201-400 of the file", "view_range": [201,400]}',
         },
       ],
     });
@@ -135,8 +123,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
           type: 'tool_use',
           id: 'toolu_01TZKs4nnBc58BYXKz1Mw4fp',
           name: 'text_editor_mcp_textEditor',
-          input:
-            '{"command": "view", "path": "/home/danny/Illuma/gistfile1.txt", "description": "Viewing lines 401-600 of the file", "view_range": [401,600]}',
+          input: '{"command": "view", "path": "/home/danny/LibreChat/gistfile1.txt", "description": "Viewing lines 401-600 of the file", "view_range": [401,600]}',
         },
       ],
     });
@@ -162,8 +149,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
           type: 'tool_use',
           id: 'toolu_01TZgBacNxjx1QNUpJg9hca5',
           name: 'text_editor_mcp_textEditor',
-          input:
-            '{"command": "view", "path": "/home/danny/Illuma/gistfile1.txt", "description": "Viewing lines 601-800 of the file", "view_range": [601,800]}',
+          input: '{"command": "view", "path": "/home/danny/LibreChat/gistfile1.txt", "description": "Viewing lines 601-800 of the file", "view_range": [601,800]}',
         },
       ],
     });
@@ -194,7 +180,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     // Create indexTokenCountMap based on the example provided
     const indexTokenCountMap = {
       '0': 617, // userMessage
-      '1': 52, // assistantMessageWithThinking
+      '1': 52,  // assistantMessageWithThinking
       '2': 4995, // toolResponseMessage1
       '3': 307, // assistantMessage2
       '4': 9359, // toolResponseMessage2
@@ -232,34 +218,22 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     expect(result.context.length).toBeGreaterThan(0);
 
     // Find the first assistant message in the pruned context
-    const firstAssistantIndex = result.context.findIndex(
-      (msg) => msg.getType() === 'ai'
-    );
+    const firstAssistantIndex = result.context.findIndex(msg => msg.getType() === 'ai');
     expect(firstAssistantIndex).toBe(0);
 
     const firstAssistantMsg = result.context[firstAssistantIndex];
     expect(Array.isArray(firstAssistantMsg.content)).toBe(true);
 
     // Verify that the first assistant message has a thinking block
-    const hasThinkingBlock = (
-      firstAssistantMsg.content as t.MessageContentComplex[]
-    ).some(
-      (item: t.MessageContentComplex) =>
-        typeof item === 'object' && item.type === 'thinking'
-    );
+    const hasThinkingBlock = (firstAssistantMsg.content as t.MessageContentComplex[]).some((item: t.MessageContentComplex) =>
+      typeof item === 'object' && item.type === 'thinking');
     expect(hasThinkingBlock).toBe(true);
 
     // Verify that the thinking block is from the original assistant message
-    const thinkingBlock = (
-      firstAssistantMsg.content as t.MessageContentComplex[]
-    ).find(
-      (item: t.MessageContentComplex) =>
-        typeof item === 'object' && item.type === 'thinking'
-    );
+    const thinkingBlock = (firstAssistantMsg.content as t.MessageContentComplex[]).find((item: t.MessageContentComplex) =>
+      typeof item === 'object' && item.type === 'thinking');
     expect(thinkingBlock).toBeDefined();
-    expect((thinkingBlock as t.ThinkingContentText).thinking).toContain(
-      'The user is asking me to read a file'
-    );
+    expect((thinkingBlock as t.ThinkingContentText).thinking).toContain('The user is asking me to read a file');
   });
 
   it('should handle token recalculation when inserting thinking blocks', () => {
@@ -477,49 +451,35 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     const result = pruneMessages({ messages });
 
     // Find assistant message with tool call and its corresponding tool message in the pruned context
-    const assistantIndex = result.context.findIndex(
-      (msg) =>
-        msg.getType() === 'ai' &&
-        Array.isArray(msg.content) &&
-        msg.content.some(
-          (item) =>
-            typeof item === 'object' &&
-            item.type === 'tool_use' &&
-            item.id === 'tool123'
-        )
+    const assistantIndex = result.context.findIndex(msg =>
+      msg.getType() === 'ai' &&
+      Array.isArray(msg.content) &&
+      msg.content.some(item => typeof item === 'object' && item.type === 'tool_use' && item.id === 'tool123')
     );
 
     // If the assistant message with tool call is in the context, its corresponding tool message should also be there
     if (assistantIndex !== -1) {
-      const toolIndex = result.context.findIndex(
-        (msg) =>
-          msg.getType() === 'tool' &&
-          'tool_call_id' in msg &&
-          msg.tool_call_id === 'tool123'
+      const toolIndex = result.context.findIndex(msg =>
+        msg.getType() === 'tool' &&
+        'tool_call_id' in msg &&
+        msg.tool_call_id === 'tool123'
       );
 
       expect(toolIndex).not.toBe(-1);
     }
 
     // If the tool message is in the context, its corresponding assistant message should also be there
-    const toolIndex = result.context.findIndex(
-      (msg) =>
-        msg.getType() === 'tool' &&
-        'tool_call_id' in msg &&
-        msg.tool_call_id === 'tool123'
+    const toolIndex = result.context.findIndex(msg =>
+      msg.getType() === 'tool' &&
+      'tool_call_id' in msg &&
+      msg.tool_call_id === 'tool123'
     );
 
     if (toolIndex !== -1) {
-      const assistantWithToolIndex = result.context.findIndex(
-        (msg) =>
-          msg.getType() === 'ai' &&
-          Array.isArray(msg.content) &&
-          msg.content.some(
-            (item) =>
-              typeof item === 'object' &&
-              item.type === 'tool_use' &&
-              item.id === 'tool123'
-          )
+      const assistantWithToolIndex = result.context.findIndex(msg =>
+        msg.getType() === 'ai' &&
+        Array.isArray(msg.content) &&
+        msg.content.some(item => typeof item === 'object' && item.type === 'tool_use' && item.id === 'tool123')
       );
 
       expect(assistantWithToolIndex).not.toBe(-1);
@@ -584,9 +544,7 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     // Calculate token counts for each message
     const indexTokenCountMapWithoutSystem: Record<string, number> = {};
     for (let i = 0; i < messagesWithoutSystem.length; i++) {
-      indexTokenCountMapWithoutSystem[i] = tokenCounter(
-        messagesWithoutSystem[i]
-      );
+      indexTokenCountMapWithoutSystem[i] = tokenCounter(messagesWithoutSystem[i]);
     }
 
     // Create pruneMessages function with thinking mode enabled
@@ -599,33 +557,24 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     });
 
     // Prune messages
-    const resultWithoutSystem = pruneMessagesWithoutSystem({
-      messages: messagesWithoutSystem,
-    });
+    const resultWithoutSystem = pruneMessagesWithoutSystem({ messages: messagesWithoutSystem });
 
     // Verify that the pruned context contains at least one message
     expect(resultWithoutSystem.context.length).toBeGreaterThan(0);
 
     // Find all assistant messages in the latest sequence (after the last human message)
-    const lastHumanIndex = resultWithoutSystem.context
-      .map((msg) => msg.getType())
-      .lastIndexOf('human');
-    const assistantMessagesAfterLastHuman = resultWithoutSystem.context
-      .slice(lastHumanIndex + 1)
-      .filter((msg) => msg.getType() === 'ai');
+    const lastHumanIndex = resultWithoutSystem.context.map(msg => msg.getType()).lastIndexOf('human');
+    const assistantMessagesAfterLastHuman = resultWithoutSystem.context.slice(lastHumanIndex + 1)
+      .filter(msg => msg.getType() === 'ai');
 
     // Verify that at least one assistant message exists in the latest sequence
     expect(assistantMessagesAfterLastHuman.length).toBeGreaterThan(0);
 
     // Verify that at least one of these assistant messages has a thinking block
-    const hasThinkingBlock = assistantMessagesAfterLastHuman.some((msg) => {
+    const hasThinkingBlock = assistantMessagesAfterLastHuman.some(msg => {
       const content = msg.content as t.MessageContentComplex[];
-      return (
-        Array.isArray(content) &&
-        content.some(
-          (item) => typeof item === 'object' && item.type === 'thinking'
-        )
-      );
+      return Array.isArray(content) && content.some(item =>
+        typeof item === 'object' && item.type === 'thinking');
     });
     expect(hasThinkingBlock).toBe(true);
 
@@ -655,36 +604,26 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     });
 
     // Prune messages
-    const resultWithSystem = pruneMessagesWithSystem({
-      messages: messagesWithSystem,
-    });
+    const resultWithSystem = pruneMessagesWithSystem({ messages: messagesWithSystem });
 
     // Verify that the system message remains first
     expect(resultWithSystem.context.length).toBeGreaterThan(1);
     expect(resultWithSystem.context[0].getType()).toBe('system');
 
     // Find all assistant messages in the latest sequence (after the last human message)
-    const lastHumanIndexWithSystem = resultWithSystem.context
-      .map((msg) => msg.getType())
-      .lastIndexOf('human');
-    const assistantMessagesAfterLastHumanWithSystem = resultWithSystem.context
-      .slice(lastHumanIndexWithSystem + 1)
-      .filter((msg) => msg.getType() === 'ai');
+    const lastHumanIndexWithSystem = resultWithSystem.context.map(msg => msg.getType()).lastIndexOf('human');
+    const assistantMessagesAfterLastHumanWithSystem = resultWithSystem.context.slice(lastHumanIndexWithSystem + 1)
+      .filter(msg => msg.getType() === 'ai');
 
     // Verify that at least one assistant message exists in the latest sequence
     expect(assistantMessagesAfterLastHumanWithSystem.length).toBeGreaterThan(0);
 
     // Verify that at least one of these assistant messages has a thinking block
-    const hasThinkingBlockWithSystem =
-      assistantMessagesAfterLastHumanWithSystem.some((msg) => {
-        const content = msg.content as t.MessageContentComplex[];
-        return (
-          Array.isArray(content) &&
-          content.some(
-            (item) => typeof item === 'object' && item.type === 'thinking'
-          )
-        );
-      });
+    const hasThinkingBlockWithSystem = assistantMessagesAfterLastHumanWithSystem.some(msg => {
+      const content = msg.content as t.MessageContentComplex[];
+      return Array.isArray(content) && content.some(item =>
+        typeof item === 'object' && item.type === 'thinking');
+    });
     expect(hasThinkingBlockWithSystem).toBe(true);
   });
 
@@ -747,23 +686,18 @@ describe('Prune Messages with Thinking Mode Tests', () => {
     const result = pruneMessages({ messages });
 
     // Find the first assistant message in the pruned context
-    const firstAssistantIndex = result.context.findIndex(
-      (msg) => msg.getType() === 'ai'
-    );
+    const firstAssistantIndex = result.context.findIndex(msg => msg.getType() === 'ai');
     expect(firstAssistantIndex).not.toBe(-1);
 
     const firstAssistantMsg = result.context[firstAssistantIndex];
     expect(Array.isArray(firstAssistantMsg.content)).toBe(true);
 
     // Verify that the first assistant message has a thinking block
-    const thinkingBlock = (
-      firstAssistantMsg.content as t.MessageContentComplex[]
-    ).find((item) => typeof item === 'object' && item.type === 'thinking');
+    const thinkingBlock = (firstAssistantMsg.content as t.MessageContentComplex[]).find(item =>
+      typeof item === 'object' && item.type === 'thinking');
     expect(thinkingBlock).toBeDefined();
 
     // Verify that it's the newer thinking block
-    expect((thinkingBlock as t.ThinkingContentText).thinking).toContain(
-      'newer thinking block'
-    );
+    expect((thinkingBlock as t.ThinkingContentText).thinking).toContain('newer thinking block');
   });
 });

package/src/stream.ts

@@ -107,6 +107,25 @@ export function getChunkContent({
         | undefined
     )?.summary?.[0]?.text;
   }
+  if (
+    provider === Providers.OPENROUTER &&
+    chunk?.additional_kwargs?.reasoning_details != null &&
+    Array.isArray(chunk.additional_kwargs.reasoning_details)
+  ) {
+    // Extract text from reasoning_details array (for Gemini, DeepSeek, etc.)
+    const textEntries = chunk.additional_kwargs.reasoning_details
+      .filter(
+        (detail) =>
+          detail.type === 'reasoning.text' &&
+          detail.text != null &&
+          detail.text !== ''
+      )
+      .map((detail) => detail.text)
+      .join('');
+    if (textEntries) {
+      return textEntries;
+    }
+  }
   return (
     ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
     chunk?.content
@@ -355,6 +374,13 @@ hasToolCallChunks: ${hasToolCallChunks}
       reasoning_content.summary[0].text
     ) {
       reasoning_content = 'valid';
+    } else if (
+      agentContext.provider === Providers.OPENROUTER &&
+      chunk.additional_kwargs?.reasoning_details != null &&
+      Array.isArray(chunk.additional_kwargs.reasoning_details) &&
+      chunk.additional_kwargs.reasoning_details.length > 0
+    ) {
+      reasoning_content = 'valid';
     }
     if (
       reasoning_content != null &&