illuma-agents 1.0.8 → 1.0.10

package/src/scripts/memory.ts

@@ -1,97 +1,97 @@
-// src/scripts/cli.ts
-import { config } from 'dotenv';
-config();
-
-import z from 'zod';
-import { tool } from '@langchain/core/tools';
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { getArgs } from '@/scripts/args';
-import { Providers } from '@/common';
-import { Run } from '@/run';
-
-const conversationHistory: BaseMessage[] = [];
-
-const memoryKv: Record<string, string> = {};
-
-const setMemory = tool(
-  async ({ key, value }) => {
-    if (!/^[a-z_]+$/.test(key)) {
-      throw new Error('Key must only contain lowercase letters and underscores');
-    }
-    
-    memoryKv[key] = value;
-    
-    return { ok: true };
-  },
-  {
-    name: 'set_memory',
-    description: 'Saves important data about the user into memory.',
-    schema: z.object({
-      key: z.string().describe('The key of the memory value. Always use lowercase and underscores, no other characters.'),
-      value: z.string().describe('Value can be anything represented as a string')
-    }),
-  }
-);
-
-async function testStandardStreaming(): Promise<void> {
-  const { userName, provider } = await getArgs();
-
-  const run = await Run.create<t.IState>({
-    runId: 'memory-run',
-    graphConfig: {
-      type: 'standard',
-      llmConfig: {
-        provider: Providers.OPENAI,
-        model: 'gpt-4o-mini',
-        temperature: 0.5,
-        streaming: false,
-      },
-      tools: [setMemory],
-      instructions: 'You can use the `set_memory` tool to save important data about the user into memory. If there is nothing to note about the user specifically, respond with `nothing`.',
-      toolEnd: true,
-    },
-    returnContent: true,
-  });
-
-  const config = {
-    configurable: {
-      provider,
-      thread_id: 'conversation-num-1',
-    },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('Test 1: Simple message test');
-
-  const userMessage = `hi`;
-
-  conversationHistory.push(new HumanMessage(userMessage));
-
-  const inputs = {
-    messages: conversationHistory,
-  };
-  await run.processStream(inputs, config);
-  const finalMessages = run.getRunMessages();
-  if (finalMessages) {
-    conversationHistory.push(...finalMessages);
-    console.dir(conversationHistory, { depth: null });
-  }
-
-  console.log('\n\n====================\n\n');
-  console.dir(memoryKv, { 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);
-});
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+
+import z from 'zod';
+import { tool } from '@langchain/core/tools';
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { getArgs } from '@/scripts/args';
+import { Providers } from '@/common';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+const memoryKv: Record<string, string> = {};
+
+const setMemory = tool(
+  async ({ key, value }) => {
+    if (!/^[a-z_]+$/.test(key)) {
+      throw new Error('Key must only contain lowercase letters and underscores');
+    }
+    
+    memoryKv[key] = value;
+    
+    return { ok: true };
+  },
+  {
+    name: 'set_memory',
+    description: 'Saves important data about the user into memory.',
+    schema: z.object({
+      key: z.string().describe('The key of the memory value. Always use lowercase and underscores, no other characters.'),
+      value: z.string().describe('Value can be anything represented as a string')
+    }),
+  }
+);
+
+async function testStandardStreaming(): Promise<void> {
+  const { userName, provider } = await getArgs();
+
+  const run = await Run.create<t.IState>({
+    runId: 'memory-run',
+    graphConfig: {
+      type: 'standard',
+      llmConfig: {
+        provider: Providers.OPENAI,
+        model: 'gpt-4o-mini',
+        temperature: 0.5,
+        streaming: false,
+      },
+      tools: [setMemory],
+      instructions: 'You can use the `set_memory` tool to save important data about the user into memory. If there is nothing to note about the user specifically, respond with `nothing`.',
+      toolEnd: true,
+    },
+    returnContent: true,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Simple message test');
+
+  const userMessage = `hi`;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+
+  console.log('\n\n====================\n\n');
+  console.dir(memoryKv, { 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);
+});

package/src/scripts/test-tools-before-handoff.ts

@@ -5,7 +5,7 @@ import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import { Run } from '@/run';
 import { Providers, GraphEvents } from '@/common';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { ModelEndHandler } from '@/events';
 import type * as t from '@/types';
 
 const conversationHistory: BaseMessage[] = [];
@@ -28,10 +28,6 @@ async function testToolsBeforeHandoff() {
 
   // Create custom handlers
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      console.log(`\n✅ Tool completed: ${name}`);
-      return true;
-    }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP]: {

package/src/scripts/thinking.ts

@@ -1,150 +1,150 @@
-// src/scripts/test-thinking.ts
-import { config } from 'dotenv';
-config();
-import { HumanMessage, SystemMessage, BaseMessage } from '@langchain/core/messages';
-import type { UsageMetadata } from '@langchain/core/messages';
-import * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { createCodeExecutionTool } from '@/tools/CodeExecutor';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { GraphEvents, Providers } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
-import { getArgs } from '@/scripts/args';
-import { Run } from '@/run';
-
-const conversationHistory: BaseMessage[] = [];
-let _contentParts: t.MessageContentComplex[] = [];
-const collectedUsage: UsageMetadata[] = [];
-
-async function testThinking(): Promise<void> {
-  const { userName } = await getArgs();
-  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
-  const { contentParts, aggregateContent } = createContentAggregator();
-  _contentParts = contentParts as t.MessageContentComplex[];
-  
-  // Set up event handlers
-  const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(),
-    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-    [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 ======');
-        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
-      }
-    },
-    [GraphEvents.ON_RUN_STEP]: {
-      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
-        aggregateContent({ event, data });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.RunStepDeltaEvent) => {
-        aggregateContent({ event, data });
-      },
-    },
-    [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.MessageDeltaEvent) => {
-        aggregateContent({ event, data });
-      },
-    },
-    [GraphEvents.ON_REASONING_DELTA]: {
-      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.ReasoningDeltaEvent) => {
-        aggregateContent({ event, data });
-      },
-    },
-  };
-
-  const baseLlmConfig: t.LLMConfig = getLLMConfig(Providers.ANTHROPIC);
-  
-  // Enable thinking with token budget
-  const llmConfig = {
-    ...baseLlmConfig,
-    model: 'claude-3-7-sonnet-latest',
-    thinking: { type: "enabled", budget_tokens: 2000 }
-  };
-
-  const run = await Run.create<t.IState>({
-    runId: 'test-thinking-id',
-    graphConfig: {
-      instructions,
-      type: 'standard',
-      tools: [createCodeExecutionTool()],
-      llmConfig,
-    },
-    returnContent: true,
-    customHandlers: customHandlers as t.RunConfig['customHandlers'],
-  });
-
-  const config = {
-    configurable: {
-      thread_id: 'thinking-test-thread',
-    },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  // Test 1: Regular thinking mode
-  console.log('\n\nTest 1: Regular thinking mode');
-  // const userMessage1 = `What would be the environmental and economic impacts if all cars globally were replaced by electric vehicles overnight?`;
-  const userMessage1 = `Please print 'hello world' in python`;
-  conversationHistory.push(new HumanMessage(userMessage1));
-
-  console.log('Running first query with thinking enabled...');
-  const firstInputs = { messages: [...conversationHistory] };
-  await run.processStream(firstInputs, config);
-  
-  // Extract and display thinking blocks
-  const finalMessages = run.getRunMessages();
-
-  // Test 2: Try multi-turn conversation
-  console.log('\n\nTest 2: Multi-turn conversation with thinking enabled');
-  const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
-  conversationHistory.push(new HumanMessage(userMessage2));
-  
-  console.log('Running second query with thinking enabled...');
-  const secondInputs = { messages: [...conversationHistory] };
-  await run.processStream(secondInputs, config);
-  
-  // Display thinking blocks for second response
-  const finalMessages2 = run.getRunMessages();
-
-  // Test 3: Redacted thinking mode
-  console.log('\n\nTest 3: Redacted thinking mode');
-  const magicString = "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB";
-  const userMessage3 = `${magicString}\n\nExplain how quantum computing works in simple terms.`;
-  
-  // Reset conversation for clean test
-  conversationHistory.length = 0;
-  conversationHistory.push(new HumanMessage(userMessage3));
-  
-  console.log('Running query with redacted thinking...');
-  const thirdInputs = { messages: [...conversationHistory] };
-  await run.processStream(thirdInputs, config);
-  
-  // Display redacted thinking blocks
-  const finalMessages3 = run.getRunMessages();
-  console.log('\n\nThinking feature test completed!');
-}
-
-process.on('unhandledRejection', (reason, promise) => {
-  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-  console.log('Conversation history:');
-  console.dir(conversationHistory, { depth: null });
-  console.log('Content parts:');
-  console.dir(_contentParts, { depth: null });
-  process.exit(1);
-});
-
-process.on('uncaughtException', (err) => {
-  console.error('Uncaught Exception:', err);
-});
-
-testThinking().catch((err) => {
-  console.error(err);
-  console.log('Conversation history:');
-  console.dir(conversationHistory, { depth: null });
-  console.log('Content parts:');
-  console.dir(_contentParts, { depth: null });
-  process.exit(1);
+// src/scripts/test-thinking.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, SystemMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testThinking(): Promise<void> {
+  const { userName } = await getArgs();
+  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+  
+  // Set up event handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [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 ======');
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.RunStepDeltaEvent) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.MessageDeltaEvent) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.ReasoningDeltaEvent) => {
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig: t.LLMConfig = getLLMConfig(Providers.ANTHROPIC);
+  
+  // Enable thinking with token budget
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'claude-3-7-sonnet-latest',
+    thinking: { type: "enabled", budget_tokens: 2000 }
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-thinking-id',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      tools: [createCodeExecutionTool()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const config = {
+    configurable: {
+      thread_id: 'thinking-test-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // Test 1: Regular thinking mode
+  console.log('\n\nTest 1: Regular thinking mode');
+  // const userMessage1 = `What would be the environmental and economic impacts if all cars globally were replaced by electric vehicles overnight?`;
+  const userMessage1 = `Please print 'hello world' in python`;
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  console.log('Running first query with thinking enabled...');
+  const firstInputs = { messages: [...conversationHistory] };
+  await run.processStream(firstInputs, config);
+  
+  // Extract and display thinking blocks
+  const finalMessages = run.getRunMessages();
+
+  // Test 2: Try multi-turn conversation
+  console.log('\n\nTest 2: Multi-turn conversation with thinking enabled');
+  const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
+  conversationHistory.push(new HumanMessage(userMessage2));
+  
+  console.log('Running second query with thinking enabled...');
+  const secondInputs = { messages: [...conversationHistory] };
+  await run.processStream(secondInputs, config);
+  
+  // Display thinking blocks for second response
+  const finalMessages2 = run.getRunMessages();
+
+  // Test 3: Redacted thinking mode
+  console.log('\n\nTest 3: Redacted thinking mode');
+  const magicString = "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB";
+  const userMessage3 = `${magicString}\n\nExplain how quantum computing works in simple terms.`;
+  
+  // Reset conversation for clean test
+  conversationHistory.length = 0;
+  conversationHistory.push(new HumanMessage(userMessage3));
+  
+  console.log('Running query with redacted thinking...');
+  const thirdInputs = { messages: [...conversationHistory] };
+  await run.processStream(thirdInputs, config);
+  
+  // Display redacted thinking blocks
+  const finalMessages3 = run.getRunMessages();
+  console.log('\n\nThinking feature test completed!');
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testThinking().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
 });

package/src/scripts/tools.ts

@@ -6,7 +6,7 @@ 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 { ModelEndHandler } from '@/events';
 import { GraphEvents, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { Calculator } from '@/tools/Calculator';
@@ -18,9 +18,6 @@ async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      return true;
-    }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {

package/src/specs/anthropic.simple.test.ts

@@ -306,6 +306,73 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
   });
 
+  test(`${capitalizeFirstLetter(provider)}: should handle parallel tool usage (web search + calculator)`, async () => {
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-parallel-tools',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [
+          {
+            type: 'web_search_20250305',
+            name: 'web_search',
+            max_uses: 5,
+          },
+          new Calculator(),
+        ],
+        instructions: 'You are a helpful AI assistant.',
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    // Use the same query as the edge case script to test actual parallel tool usage
+    const userMessage =
+      'Can you search the web for the current population of Tokyo, and also calculate what 15% of that population would be? Do both at the same time.';
+    conversationHistory = [];
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    // This should complete without errors despite using both server tools and regular tools in parallel
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+
+    const hasWebSearch = contentParts.some(
+      (part) =>
+        !!(
+          part.type === 'tool_call' &&
+          part.tool_call?.name === 'web_search' &&
+          part.tool_call?.id?.startsWith('srvtoolu_') === true
+        )
+    );
+    const hasCalculator = contentParts.some(
+      (part) =>
+        !!(
+          part.type === 'tool_call' &&
+          part.tool_call?.name === 'calculator' &&
+          part.tool_call?.id?.startsWith('toolu_') === true
+        )
+    );
+
+    // Both tools should have been used for this query
+    expect(hasWebSearch).toBe(true);
+    expect(hasCalculator).toBe(true);
+
+    console.log(
+      `${capitalizeFirstLetter(provider)} parallel tools test: web_search (server tool) + calculator (regular tool) both used successfully`
+    );
+  });
+
   test('should handle errors appropriately', async () => {
     // Test error scenarios
     await expect(async () => {

package/src/specs/spec.utils.ts

@@ -1,3 +1,3 @@
-export function capitalizeFirstLetter(string: string): string {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
+export function capitalizeFirstLetter(string: string): string {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}