@illuma-ai/agents 1.0.81

package/src/scripts/tool_search.ts

@@ -0,0 +1,162 @@
+// src/scripts/tool_search.ts
+/**
+ * Test script for the Tool Search Regex tool.
+ * Run with: npm run tool_search
+ *
+ * Demonstrates runtime registry injection - the tool registry is passed
+ * at invocation time, not at initialization time.
+ */
+import { config } from 'dotenv';
+config();
+
+import { createToolSearch } from '@/tools/ToolSearch';
+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 createToolSearch>,
+  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.CODE_EXECUTOR_API_KEY;
+  if (!apiKey) {
+    console.error(
+      'Error: CODE_EXECUTOR_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 = createToolSearch({ 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/scripts/tools.ts

@@ -0,0 +1,177 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { Calculator } from '@/tools/Calculator';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(
+      undefined,
+      undefined,
+      (name?: string) => {
+        return true;
+      }
+    ),
+    [GraphEvents.CHAT_MODEL_END]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== CHAT_MODEL_END METADATA ======');
+        console.dir(metadata, { depth: null });
+      },
+    },
+    [GraphEvents.CHAT_MODEL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== CHAT_MODEL_START METADATA ======');
+        console.dir(metadata, { depth: null });
+      },
+    },
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.StreamEventData
+      ) => {
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  if (llmConfig.provider === Providers.BEDROCK) {
+    (llmConfig as t.BedrockAnthropicInput).promptCache = true;
+  }
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-run-id',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [new Calculator()],
+      instructions:
+        'You are a friendly AI assistant. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      maxContextTokens: 89000,
+    },
+    indexTokenCountMap: { 0: 35 },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Calculation query');
+
+  const userMessage = `What is 1123123 + 123123 / 20348? After that, run some interesting calculations based off the result`;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  // console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});