illuma-agents 1.0.2 → 1.0.3

package/src/scripts/handoff-test.ts

@@ -0,0 +1,135 @@
+import { config } from 'dotenv';
+config();
+
+import { z } from 'zod';
+import { tool } from '@langchain/core/tools';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import {
+  StateGraph,
+  MessagesAnnotation,
+  Command,
+  START,
+  getCurrentTaskInput,
+  END,
+} from '@langchain/langgraph';
+import { ToolMessage } from '@langchain/core/messages';
+
+interface CreateHandoffToolParams {
+  agentName: string;
+  description?: string;
+}
+
+const createHandoffTool = ({
+  agentName,
+  description,
+}: CreateHandoffToolParams) => {
+  const toolName = `transfer_to_${agentName}`;
+  const toolDescription = description || `Ask agent '${agentName}' for help`;
+
+  const handoffTool = tool(
+    async (_, config) => {
+      const toolMessage = new ToolMessage({
+        content: `Successfully transferred to ${agentName}`,
+        name: toolName,
+        tool_call_id: config.toolCall.id,
+      });
+
+      // inject the current agent state
+      const state =
+        getCurrentTaskInput() as (typeof MessagesAnnotation)['State'];
+      return new Command({
+        goto: agentName,
+        update: { messages: state.messages.concat(toolMessage) },
+        graph: Command.PARENT,
+      });
+    },
+    {
+      name: toolName,
+      schema: z.object({}),
+      description: toolDescription,
+    }
+  );
+
+  return handoffTool;
+};
+
+const bookHotel = tool(
+  async (input: { hotel_name: string }) => {
+    return `Successfully booked a stay at ${input.hotel_name}.`;
+  },
+  {
+    name: 'book_hotel',
+    description: 'Book a hotel',
+    schema: z.object({
+      hotel_name: z.string().describe('The name of the hotel to book'),
+    }),
+  }
+);
+
+const bookFlight = tool(
+  async (input: { from_airport: string; to_airport: string }) => {
+    return `Successfully booked a flight from ${input.from_airport} to ${input.to_airport}.`;
+  },
+  {
+    name: 'book_flight',
+    description: 'Book a flight',
+    schema: z.object({
+      from_airport: z.string().describe('The departure airport code'),
+      to_airport: z.string().describe('The arrival airport code'),
+    }),
+  }
+);
+
+const transferToHotelAssistant = createHandoffTool({
+  agentName: 'hotel_assistant',
+  description: 'Transfer user to the hotel-booking assistant.',
+});
+
+const transferToFlightAssistant = createHandoffTool({
+  agentName: 'flight_assistant',
+  description: 'Transfer user to the flight-booking assistant.',
+});
+
+const llm = new ChatAnthropic({
+  modelName: 'claude-haiku-4-5',
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+const flightAssistant = createReactAgent({
+  llm,
+  tools: [bookFlight, transferToHotelAssistant],
+  prompt: 'You are a flight booking assistant',
+  name: 'flight_assistant',
+});
+
+const hotelAssistant = createReactAgent({
+  llm,
+  tools: [bookHotel, transferToFlightAssistant],
+  prompt: 'You are a hotel booking assistant',
+  name: 'hotel_assistant',
+});
+
+const multiAgentGraph = new StateGraph(MessagesAnnotation)
+  .addNode('flight_assistant', flightAssistant, {
+    ends: ['hotel_assistant', END],
+  })
+  .addNode('hotel_assistant', hotelAssistant, {
+    ends: ['flight_assistant', END],
+  })
+  .addEdge(START, 'flight_assistant')
+  .compile();
+
+const stream = await multiAgentGraph.stream({
+  messages: [
+    {
+      role: 'user',
+      content: 'book a flight from BOS to JFK and a stay at McKittrick Hotel',
+    },
+  ],
+});
+
+for await (const chunk of stream) {
+  console.log(chunk);
+  console.log('\n');
+}

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

@@ -0,0 +1,278 @@
+import { config } from 'dotenv';
+config();
+
+import {
+  HumanMessage,
+  BaseMessage,
+  getBufferString,
+} from '@langchain/core/messages';
+import { Run } from '@/run';
+import { Providers, GraphEvents } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+/**
+ * Helper function to create sequential chain edges with buffer string prompts
+ *
+ * @param agentIds - Array of agent IDs in order of execution
+ * @returns Array of edges configured for sequential chain with buffer prompts
+ */
+function createSequentialChainEdges(agentIds: string[]): t.GraphEdge[] {
+  const edges: t.GraphEdge[] = [];
+
+  for (let i = 0; i < agentIds.length - 1; i++) {
+    const fromAgent = agentIds[i];
+    const toAgent = agentIds[i + 1];
+
+    edges.push({
+      from: fromAgent,
+      to: toAgent,
+      edgeType: 'direct',
+      // Use a prompt function to create the buffer string from all previous results
+      prompt: (messages: BaseMessage[], startIndex: number) => {
+        // Get only the messages from this run (after startIndex)
+        const runMessages = messages.slice(startIndex);
+
+        // Create buffer string from run messages
+        const bufferString = getBufferString(runMessages);
+
+        // Format the prompt for the next agent
+        return `Based on the following conversation and analysis from previous agents, please provide your insights:\n\n${bufferString}\n\nPlease add your specific expertise and perspective to this discussion.`;
+      },
+      // Critical: exclude previous results so only the prompt is passed
+      excludeResults: true,
+      description: `Sequential chain from ${fromAgent} to ${toAgent}`,
+    });
+  }
+
+  return edges;
+}
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of sequential agent chain mimicking the old chain behavior
+ *
+ * Graph structure:
+ * START -> researcher -> analyst -> reviewer -> summarizer -> END
+ *
+ * Each agent receives a buffer string of all previous results
+ */
+async function testSequentialAgentChain() {
+  console.log('Testing Sequential Agent Chain (Old Chain Pattern)...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define four agents with specific roles
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'researcher',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Research Agent specializing in gathering initial information.
+      Your role is to:
+      1. Identify key aspects of the user's query
+      2. List important factors to consider
+      3. Provide initial research findings
+      
+      Format your response with clear sections and bullet points.
+      Start with "RESEARCH FINDINGS:" and be thorough but concise.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'analyst',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are an Analysis Agent that builds upon research findings.
+      Your role is to:
+      1. Analyze the research provided by the previous agent
+      2. Identify patterns, risks, and opportunities
+      3. Provide deeper analytical insights
+      
+      Start with "ANALYSIS:" and structure your response with clear categories.
+      Reference specific points from the research when relevant.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'reviewer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Critical Review Agent that evaluates the work done so far.
+      Your role is to:
+      1. Review the research and analysis from previous agents
+      2. Identify any gaps or areas that need more attention
+      3. Suggest improvements or additional considerations
+      
+      Start with "CRITICAL REVIEW:" and be constructive in your feedback.
+      Highlight both strengths and areas for improvement.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'summarizer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Summary Agent that creates the final comprehensive output.
+      Your role is to:
+      1. Synthesize all insights from the researcher, analyst, and reviewer
+      2. Create a cohesive, actionable summary
+      3. Provide clear recommendations or conclusions
+      
+      Start with "EXECUTIVE SUMMARY:" followed by key sections.
+      End with "KEY RECOMMENDATIONS:" or "CONCLUSIONS:" as appropriate.`,
+      maxContextTokens: 8000,
+    },
+  ];
+
+  // Create sequential chain edges using our helper function
+  const agentIds = agents.map((a) => a.agentId);
+  const edges = createSequentialChainEdges(agentIds);
+
+  // Track agent progression
+  let currentAgent = '';
+
+  // Create custom handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          currentAgent = runStepData.name;
+          console.log(`\n→ ${currentAgent} is processing...`);
+        }
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          console.log(`✓ ${runStepData.name} completed`);
+        }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [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 });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `sequential-chain-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    // Test with a complex question that benefits from multiple perspectives
+    const userMessage =
+      'I want to launch a new mobile app for personal finance management. What should I consider?';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log(`User: "${userMessage}"\n`);
+    console.log('Starting sequential agent chain...\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'sequential-chain-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    // Process with streaming
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+    }
+
+    console.log('\n\n=== Final Output ===');
+    console.log('Sequential chain completed successfully!');
+    console.log(`Total content parts: ${contentParts.length}`);
+
+    // Display the buffer accumulation
+    console.log('\n=== Agent Outputs (Buffer Accumulation) ===');
+
+    const aiMessages = conversationHistory.filter(
+      (msg) => msg._getType() === 'ai'
+    );
+
+    aiMessages.forEach((msg, index) => {
+      console.log(`\n--- Agent ${index + 1}: ${agentIds[index]} ---`);
+      console.log(msg.content);
+
+      // Show buffer preview for next agent (except last)
+      if (index < aiMessages.length - 1) {
+        const bufferSoFar = getBufferString(aiMessages.slice(0, index + 1));
+        console.log(
+          `\n[Buffer passed to ${agentIds[index + 1]}]: ${bufferSoFar.slice(0, 150)}...`
+        );
+      }
+    });
+
+    // Demonstrate that each agent built upon previous results
+    console.log('\n=== Chain Analysis ===');
+    console.log('1. Researcher provided initial findings');
+    console.log('2. Analyst built upon research with deeper insights');
+    console.log('3. Reviewer critiqued and identified gaps');
+    console.log('4. Summarizer synthesized everything into actionable output');
+  } catch (error) {
+    console.error('Error in sequential agent chain test:', error);
+  }
+}
+
+// Run the test
+testSequentialAgentChain();

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

@@ -0,0 +1,220 @@
+import { config } from 'dotenv';
+config();
+
+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 type * as t from '@/types';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of conditional multi-agent system
+ *
+ * Graph structure:
+ * START -> classifier
+ * classifier -> technical_expert (if technical question)
+ * classifier -> business_expert (if business question)
+ * classifier -> general_assistant (otherwise)
+ * [all experts] -> END
+ */
+async function testConditionalMultiAgent() {
+  console.log('Testing Conditional Multi-Agent System...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define specialized agents
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'classifier',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a query classifier. Analyze user questions and determine if they are technical, business-related, or general.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'technical_expert',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a technical expert. Provide detailed technical answers about programming, systems, and technology.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'business_expert',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a business expert. Provide insights on business strategy, operations, and management.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'general_assistant',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a helpful general assistant. Answer questions on a wide range of topics.',
+      maxContextTokens: 8000,
+    },
+  ];
+
+  // Define conditional edges
+  // These create handoff tools with conditional routing logic
+  const edges: t.GraphEdge[] = [
+    {
+      from: 'classifier',
+      to: ['technical_expert', 'business_expert', 'general_assistant'],
+      description: 'Route to appropriate expert based on query type',
+      condition: (state: t.BaseGraphState) => {
+        // Simple keyword-based routing for demo
+        // In a real system, this would use the classifier's analysis
+        const lastMessage = state.messages[state.messages.length - 1];
+        const content = lastMessage.content?.toString().toLowerCase() || '';
+
+        if (
+          content.includes('code') ||
+          content.includes('programming') ||
+          content.includes('technical')
+        ) {
+          return 'technical_expert';
+        } else if (
+          content.includes('business') ||
+          content.includes('strategy') ||
+          content.includes('market')
+        ) {
+          return 'business_expert';
+        } else {
+          return 'general_assistant';
+        }
+      },
+    },
+  ];
+
+  // Track selected expert
+  let selectedExpert = '';
+
+  // Create custom handlers
+  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 => {
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name && runStepData.name !== 'classifier') {
+          selectedExpert = runStepData.name;
+          console.log(`Routing to: ${selectedExpert}`);
+        }
+        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 });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `conditional-multi-agent-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    // Test with different types of questions
+    const testQuestions = [
+      'How do I implement a binary search tree in Python?',
+      'What are the key strategies for market expansion?',
+      'What is the capital of France?',
+    ];
+
+    const config = {
+      configurable: {
+        thread_id: 'conditional-conversation-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    for (const question of testQuestions) {
+      console.log(`\n--- Processing: "${question}" ---\n`);
+
+      // Reset for each question
+      selectedExpert = '';
+      conversationHistory.length = 0;
+      conversationHistory.push(new HumanMessage(question));
+
+      // Process with streaming
+      const inputs = {
+        messages: conversationHistory,
+      };
+
+      const finalContentParts = await run.processStream(inputs, config);
+      const finalMessages = run.getRunMessages();
+
+      if (finalMessages) {
+        conversationHistory.push(...finalMessages);
+      }
+
+      console.log(`\n\nExpert used: ${selectedExpert}`);
+      console.log('Content parts:', contentParts.length);
+      console.log('---');
+    }
+  } catch (error) {
+    console.error('Error in conditional multi-agent test:', error);
+  }
+}
+
+// Run the test
+testConditionalMultiAgent();