illuma-agents 1.0.36 → 1.0.38

package/src/scripts/code_exec_multi_session.ts

@@ -0,0 +1,241 @@
+// src/scripts/code_exec_multi_session.ts
+/**
+ * Tests multi-session file tracking for code execution.
+ * Verifies that:
+ * 1. Files from multiple executions are accumulated
+ * 2. Each file tracks its source session_id
+ * 3. Edited/recreated files replace older versions (latest preferred)
+ *
+ * Run with: npm run code_exec_multi_session
+ */
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ChatModelStreamHandler } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Constants, GraphEvents } from '@/common';
+import { Run } from '@/run';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Prints session context from the graph
+ */
+function printSessionContext(run: Run<t.IState>, label: string): void {
+  const graph = run.Graph;
+  if (!graph) {
+    console.log(`\n[${label}] No graph available`);
+    return;
+  }
+
+  const session = graph.sessions.get(Constants.EXECUTE_CODE) as
+    | t.CodeSessionContext
+    | undefined;
+
+  console.log(`\n========== ${label} ==========`);
+  if (!session) {
+    console.log('  No session context stored yet');
+    return;
+  }
+
+  console.log(`  Latest session_id: ${session.session_id}`);
+  console.log(`  Files tracked: ${session.files.length}`);
+  for (const file of session.files) {
+    console.log(`    - ${file.name} (session: ${file.session_id})`);
+  }
+}
+
+async function testMultiSessionFiles(): Promise<void> {
+  const { provider } = await getArgs();
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    runId: 'multi-session-test',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [createCodeExecutionTool()],
+      instructions: `You are a coding assistant. Execute code exactly as requested.
+When asked to create files, use Python and save to /mnt/data/.
+When reading files, print their contents.
+Be concise in responses.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const streamConfig: Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    streamMode: string;
+  } = {
+    configurable: {
+      provider,
+      thread_id: 'multi-session-test',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // ========== TEST 1: Create first file ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 1: Create first file (file_a.txt)');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create a file called "file_a.txt" with the content:
+"This is file A, version 1"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages1 = run.getRunMessages();
+  if (messages1) conversationHistory.push(...messages1);
+
+  printSessionContext(run, 'After Test 1');
+
+  // ========== TEST 2: Create second file (different session) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 2: Create second file (file_b.txt)');
+  console.log('Expecting: Both file_a.txt and file_b.txt tracked');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create a NEW file called "file_b.txt" with the content:
+"This is file B"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages2 = run.getRunMessages();
+  if (messages2) conversationHistory.push(...messages2);
+
+  printSessionContext(run, 'After Test 2');
+
+  // ========== TEST 3: Read BOTH files (verifies accumulation) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 3: Read BOTH files from previous executions');
+  console.log('This verifies multi-session file accumulation works');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Read and print the contents of BOTH files:
+1. file_a.txt
+2. file_b.txt
+
+Show me what's in each file.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages3 = run.getRunMessages();
+  if (messages3) conversationHistory.push(...messages3);
+
+  printSessionContext(run, 'After Test 3');
+
+  // ========== TEST 4: Edit file_a.txt (verifies latest-wins) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 4: Edit file_a.txt (create new version)');
+  console.log('Expecting: Old file_a.txt replaced with new version');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create an UPDATED version of "file_a.txt" with the content:
+"This is file A, version 2 - UPDATED"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages4 = run.getRunMessages();
+  if (messages4) conversationHistory.push(...messages4);
+
+  printSessionContext(run, 'After Test 4');
+
+  // ========== TEST 5: Read file_a.txt (verifies latest version) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 5: Read file_a.txt to verify it has the UPDATED content');
+  console.log('Expected: "version 2 - UPDATED" NOT "version 1"');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Read and print the contents of file_a.txt.
+Tell me what version it shows.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages5 = run.getRunMessages();
+  if (messages5) conversationHistory.push(...messages5);
+
+  printSessionContext(run, 'Final Session State');
+
+  // ========== SUMMARY ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST SUMMARY');
+  console.log('='.repeat(60));
+
+  const finalSession = run.Graph?.sessions.get(Constants.EXECUTE_CODE) as
+    | t.CodeSessionContext
+    | undefined;
+
+  if (finalSession) {
+    const uniqueSessionIds = new Set(
+      finalSession.files.map((f) => f.session_id)
+    );
+    console.log(`\nTotal files tracked: ${finalSession.files.length}`);
+    console.log(`Unique session_ids: ${uniqueSessionIds.size}`);
+    console.log('\nFiles:');
+    for (const file of finalSession.files) {
+      console.log(
+        `  - ${file.name} (session: ${file.session_id?.slice(0, 20)}...)`
+      );
+    }
+
+    // Verify expectations
+    const fileACount = finalSession.files.filter(
+      (f) => f.name === 'file_a.txt'
+    ).length;
+    const fileBCount = finalSession.files.filter(
+      (f) => f.name === 'file_b.txt'
+    ).length;
+
+    console.log('\n✓ Checks:');
+    console.log(`  file_a.txt count: ${fileACount} (expected: 1, latest wins)`);
+    console.log(`  file_b.txt count: ${fileBCount} (expected: 1)`);
+
+    if (fileACount === 1 && fileBCount === 1) {
+      console.log('\n✅ All tests passed! Multi-session tracking works.');
+    } else {
+      console.log('\n❌ Test failed - unexpected file counts');
+    }
+  }
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
+
+testMultiSessionFiles().catch((err) => {
+  console.error('Test failed:', err);
+  process.exit(1);
+});

package/src/scripts/code_exec_session.ts

@@ -0,0 +1,282 @@
+// src/scripts/code_exec_session.ts
+/**
+ * Test script for automatic session tracking in code execution tools.
+ *
+ * This tests the automatic session_id injection feature where:
+ * 1. First code execution generates files and returns a session_id
+ * 2. Session context is stored in Graph.sessions
+ * 3. Subsequent code executions automatically have access to previous files
+ *    without the LLM needing to explicitly pass session_id
+ *
+ * Run with: npm run code_exec_session
+ */
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import {
+  ToolEndHandler,
+  ModelEndHandler,
+  createMetadataAggregator,
+} from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Constants, GraphEvents } from '@/common';
+import { Run } from '@/run';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Prints a formatted section header for test output
+ */
+function printSection(title: string): void {
+  console.log('\n' + '='.repeat(60));
+  console.log(` ${title}`);
+  console.log('='.repeat(60) + '\n');
+}
+
+/**
+ * Prints session context from the graph for debugging
+ */
+function printSessionContext(run: Run<t.IState>): void {
+  const graph = run.Graph;
+  if (!graph) {
+    console.log('[Session] No graph available');
+    return;
+  }
+
+  const session = graph.sessions.get(Constants.EXECUTE_CODE) as
+    | t.CodeSessionContext
+    | undefined;
+
+  if (!session) {
+    console.log('[Session] No session context stored yet');
+    return;
+  }
+
+  console.log('[Session] Current session context:');
+  console.log(`  - session_id: ${session.session_id}`);
+  console.log(`  - files: ${JSON.stringify(session.files, null, 2)}`);
+  console.log(
+    `  - lastUpdated: ${new Date(session.lastUpdated).toISOString()}`
+  );
+}
+
+async function testAutomaticSessionTracking(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { 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
+      ): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { 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.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        _metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    runId: 'session-tracking-test-1',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [createCodeExecutionTool()],
+      instructions: `You are an AI assistant testing automatic file persistence.
+When writing Python code:
+- Use print() for all outputs
+- Files from previous executions are automatically available in /mnt/data/
+- Files are READ-ONLY; write modifications to NEW filenames
+- IMPORTANT: Do NOT include session_id in your tool calls - it's handled automatically.`,
+      additional_instructions: `User: ${userName}, Location: ${location}, Date: ${currentDate}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const streamConfig: Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    run_id?: string;
+    streamMode: string;
+  } = {
+    configurable: {
+      provider,
+      thread_id: 'session-tracking-test',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // =========================================================================
+  // Test 1: Create initial file (establishes session)
+  // =========================================================================
+  printSection('Test 1: Create Initial File');
+  console.log(
+    'This test creates a file, which should establish a session context.\n'
+  );
+
+  const userMessage1 = `
+Create a Python file that writes a simple JSON config file named "app_config.json" with the following content:
+{
+  "app_name": "TestApp",
+  "version": "1.0.0",
+  "debug": true
+}
+
+After writing, print the contents to confirm it was created correctly.
+`;
+
+  conversationHistory.push(new HumanMessage(userMessage1));
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+
+  const finalMessages1 = run.getRunMessages();
+  if (finalMessages1) {
+    conversationHistory.push(...finalMessages1);
+  }
+
+  printSection('Session Context After Test 1');
+  printSessionContext(run);
+
+  // =========================================================================
+  // Test 2: Access previously created file (uses automatic session injection)
+  // =========================================================================
+  printSection('Test 2: Access Previous File (Automatic Session)');
+  console.log('This test reads the file created in Test 1.');
+  console.log(
+    'The LLM does NOT need to provide session_id - it should be injected automatically.\n'
+  );
+
+  const userMessage2 = `
+Now read the app_config.json file that was just created and:
+1. Print its contents
+2. Confirm the version is "1.0.0"
+
+Note: You should be able to access this file from the previous execution automatically.
+`;
+
+  conversationHistory.push(new HumanMessage(userMessage2));
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+
+  const finalMessages2 = run.getRunMessages();
+  if (finalMessages2) {
+    conversationHistory.push(...finalMessages2);
+  }
+
+  printSection('Session Context After Test 2');
+  printSessionContext(run);
+
+  // =========================================================================
+  // Test 3: Modify file (write to new filename)
+  // =========================================================================
+  printSection('Test 3: Modify File (Write to New Filename)');
+  console.log(
+    'This test modifies the config by reading the old file and writing a new one.\n'
+  );
+
+  const userMessage3 = `
+Read app_config.json, update the version to "2.0.0" and debug to false, 
+then save it as "app_config_v2.json". Print both the old and new contents.
+`;
+
+  conversationHistory.push(new HumanMessage(userMessage3));
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+
+  const finalMessages3 = run.getRunMessages();
+  if (finalMessages3) {
+    conversationHistory.push(...finalMessages3);
+  }
+
+  printSection('Session Context After Test 3');
+  printSessionContext(run);
+
+  // =========================================================================
+  // Summary
+  // =========================================================================
+  printSection('Test Summary');
+  console.log('The automatic session tracking feature should have:');
+  console.log('1. Stored the session_id after the first code execution');
+  console.log('2. Automatically injected it into subsequent executions');
+  console.log('3. Accumulated file references across all executions');
+  console.log('\nCheck the session context output above to verify.\n');
+
+  // Generate title
+  const { handleLLMEnd, collected } = createMetadataAggregator();
+  const titleResult = await run.generateTitle({
+    provider,
+    inputText: 'Testing automatic session tracking for code execution',
+    contentParts,
+    chainOptions: {
+      callbacks: [{ handleLLMEnd }],
+    },
+  });
+  console.log('Generated Title:', titleResult);
+  console.log('Collected metadata:', collected);
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testAutomaticSessionTracking().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/multi-agent-conditional.ts

@@ -210,6 +210,7 @@ async function testConditionalMultiAgent() {
       console.log(`\n\nExpert used: ${selectedExpert}`);
       console.log('Content parts:', contentParts.length);
       console.log('---');
+      console.dir(contentParts, { depth: null });
     }
   } catch (error) {
     console.error('Error in conditional multi-agent test:', error);

package/src/scripts/multi-agent-supervisor.ts

@@ -353,6 +353,7 @@ async function testSupervisorMultiAgent() {
       );
       console.log(`                 transfer_to_legal_advisor`);
       console.log('─'.repeat(60));
+      console.dir(contentParts, { depth: null });
     }
     await sleep(3000);
   } catch (error) {

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)'