illuma-agents 1.0.27 → 1.0.29

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

@@ -200,18 +200,50 @@ async function testParallelMultiAgent() {
 
   // Track which agents are active
   const activeAgents = new Set<string>();
+  const startTime = Date.now();
+  let messageCount = 0;
 
-  // Create custom handlers
+  // Create custom handlers with extensive metadata logging
   const customHandlers = {
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
-    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [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 });
+        const elapsed = Date.now() - startTime;
+        const nodeName = metadata?.langgraph_node as string;
+        console.log(`⏱️  [${nodeName || 'unknown'}] COMPLETED at ${elapsed}ms`);
+      },
+    },
+    [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 });
+        const elapsed = Date.now() - startTime;
+        const nodeName = metadata?.langgraph_node as string;
+        console.log(`⏱️  [${nodeName || 'unknown'}] STARTED at ${elapsed}ms`);
+      },
+    },
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
-        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.log('\n====== ON_RUN_STEP_COMPLETED ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
         const runStepData = data as any;
         if (runStepData?.name) {
           activeAgents.delete(runStepData.name);
@@ -226,9 +258,14 @@ async function testParallelMultiAgent() {
     [GraphEvents.ON_RUN_STEP]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
-        console.log('====== ON_RUN_STEP ======');
+        console.log('\n====== ON_RUN_STEP ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
         const runStepData = data as any;
         if (runStepData?.name) {
           activeAgents.add(runStepData.name);
@@ -240,18 +277,32 @@ async function testParallelMultiAgent() {
     [GraphEvents.ON_RUN_STEP_DELTA]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_DELTA,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
+        console.log('\n====== ON_RUN_STEP_DELTA ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
         aggregateContent({ event, data: data as t.RunStepDeltaEvent });
       },
     },
     [GraphEvents.ON_MESSAGE_DELTA]: {
       handle: (
         event: GraphEvents.ON_MESSAGE_DELTA,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
-        console.log('====== ON_MESSAGE_DELTA ======');
-        console.dir(data, { depth: null });
+        messageCount++;
+        // Only log first few message deltas per agent to avoid spam
+        if (messageCount <= 5) {
+          console.log('\n====== ON_MESSAGE_DELTA ======');
+          console.log('DATA:');
+          console.dir(data, { depth: null });
+          console.log('METADATA:');
+          console.dir(metadata, { depth: null });
+        }
         aggregateContent({ event, data: data as t.MessageDeltaEvent });
       },
     },

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

@@ -22,7 +22,8 @@ async function testSequentialMultiAgent() {
   console.log('Testing Sequential Multi-Agent System (A → B → C)...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent } = createContentAggregator();
+  const { contentParts, aggregateContent, contentMetadataMap } =
+    createContentAggregator();
 
   // Define three simple agents
   const agents: t.AgentInputs[] = [
@@ -194,6 +195,10 @@ async function testSequentialMultiAgent() {
     console.log('\n\n=== Final Output ===');
     console.log('Sequential flow completed successfully!');
     console.log(`Total content parts: ${contentParts.length}`);
+    console.log('\n=== Content Parts (clean, no metadata) ===');
+    console.dir(contentParts, { depth: null });
+    console.log('\n=== Content Metadata Map (separate from content) ===');
+    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
 
     // Display the sequential responses
     const aiMessages = conversationHistory.filter(

package/src/scripts/parallel-asymmetric-tools-test.ts

@@ -0,0 +1,274 @@
+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 } from '@/events';
+import { Providers, GraphEvents } from '@/common';
+import { sleep } from '@/utils/run';
+import { Run } from '@/run';
+import { Calculator } from '@/tools/Calculator';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Test ASYMMETRIC parallel execution:
+ * - agent1: NO tools (will finish quickly in step 1)
+ * - agent2: HAS tools (will go step 1 → step 2 → step 3)
+ *
+ * This tests whether langgraph_step can still detect parallel execution
+ * when agents have different tool-calling patterns.
+ */
+async function testAsymmetricParallelTools() {
+  console.log(
+    'Testing ASYMMETRIC Parallel Agents (one with tools, one without)...\n'
+  );
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Track metadata for analysis
+  const metadataLog: Array<{
+    event: string;
+    langgraph_step: number;
+    langgraph_node: string;
+    timestamp: number;
+  }> = [];
+  const startTime = Date.now();
+
+  // Define two agents - one WITH tools, one WITHOUT
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'simple_agent',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      // NO TOOLS - will complete in single step
+      instructions: `You are a simple assistant. Just answer the question directly in 1-2 sentences. Start with "🗣️ SIMPLE:". Do NOT try to use any tools.`,
+    },
+    {
+      agentId: 'math_agent',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      tools: [new Calculator()],
+      instructions: `You are a MATH SPECIALIST. ALWAYS use the calculator tool to perform calculations, even simple ones. Start your response with "🧮 MATH:". Keep your response concise.`,
+    },
+  ];
+
+  // No edges - both run in parallel from start
+  const edges: t.GraphEdge[] = [];
+
+  const agentTimings: Record<string, { start?: number; end?: number }> = {};
+
+  // Helper to log metadata
+  const logMetadata = (
+    eventName: string,
+    metadata?: Record<string, unknown>
+  ) => {
+    if (metadata) {
+      const entry = {
+        event: eventName,
+        langgraph_step: metadata.langgraph_step as number,
+        langgraph_node: metadata.langgraph_node as string,
+        timestamp: Date.now() - startTime,
+      };
+      metadataLog.push(entry);
+      console.log(
+        `📊 [${entry.timestamp}ms] ${eventName}: step=${entry.langgraph_step}, node=${entry.langgraph_node}`
+      );
+    }
+  };
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== TOOL_END ======');
+        logMetadata('TOOL_END', metadata);
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== TOOL_START ======');
+        logMetadata('TOOL_START', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_END]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== CHAT_MODEL_END ======');
+        logMetadata('CHAT_MODEL_END', metadata);
+        const nodeName = metadata?.langgraph_node as string;
+        if (nodeName) {
+          const elapsed = Date.now() - startTime;
+          agentTimings[nodeName] = agentTimings[nodeName] || {};
+          agentTimings[nodeName].end = elapsed;
+        }
+      },
+    },
+    [GraphEvents.CHAT_MODEL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== CHAT_MODEL_START ======');
+        logMetadata('CHAT_MODEL_START', metadata);
+        const nodeName = metadata?.langgraph_node as string;
+        if (nodeName) {
+          const elapsed = Date.now() - startTime;
+          agentTimings[nodeName] = agentTimings[nodeName] || {};
+          if (!agentTimings[nodeName].start) {
+            agentTimings[nodeName].start = elapsed;
+          }
+        }
+      },
+    },
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== ON_RUN_STEP ======');
+        logMetadata('ON_RUN_STEP', metadata);
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        // Don't log these to reduce noise
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        // Don't log these to reduce noise
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+  };
+
+  const runConfig: t.RunConfig = {
+    runId: `asymmetric-parallel-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    const run = await Run.create(runConfig);
+
+    // Ask a question that will trigger only the math agent to use tools
+    const userMessage = `What is 42 * 17?`;
+
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log('User message:', userMessage);
+    console.log('\nExpected behavior:');
+    console.log('  - simple_agent: Step 1 only (no tools)');
+    console.log('  - math_agent: Step 1 → Step 2 (tool) → Step 3 (response)');
+    console.log('\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'asymmetric-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    await run.processStream(inputs, config);
+
+    // Analysis
+    console.log('\n\n========== METADATA ANALYSIS ==========');
+    console.log('\nAll events by step and node:');
+    console.table(metadataLog);
+
+    // Group by step
+    const stepGroups = new Map<number, Map<string, string[]>>();
+    for (const entry of metadataLog) {
+      if (!stepGroups.has(entry.langgraph_step)) {
+        stepGroups.set(entry.langgraph_step, new Map());
+      }
+      const nodeMap = stepGroups.get(entry.langgraph_step)!;
+      if (!nodeMap.has(entry.langgraph_node)) {
+        nodeMap.set(entry.langgraph_node, []);
+      }
+      nodeMap.get(entry.langgraph_node)!.push(entry.event);
+    }
+
+    console.log('\n\n========== STEP BREAKDOWN ==========');
+    for (const [step, nodeMap] of stepGroups) {
+      console.log(`\nStep ${step}:`);
+      for (const [node, events] of nodeMap) {
+        console.log(`  ${node}: ${events.join(', ')}`);
+      }
+      console.log(`  → ${nodeMap.size} unique node(s) at this step`);
+    }
+
+    console.log('\n\n========== PARALLEL DETECTION CHALLENGE ==========');
+    console.log('\nAt which steps can we detect parallel execution?');
+    for (const [step, nodeMap] of stepGroups) {
+      if (nodeMap.size > 1) {
+        console.log(
+          `  ✅ Step ${step}: ${nodeMap.size} agents detected - PARALLEL`
+        );
+      } else {
+        const [nodeName] = nodeMap.keys();
+        console.log(
+          `  ⚠️  Step ${step}: Only 1 agent (${nodeName}) - looks sequential!`
+        );
+      }
+    }
+
+    console.log('\n\n========== KEY INSIGHT ==========');
+    console.log(
+      'If we only look at step 2 or 3, we miss the parallel context!'
+    );
+    console.log(
+      'We need to detect parallelism EARLY (at step 1) and carry that forward.'
+    );
+
+    console.log('\n\nFinal content parts:');
+    console.dir(contentParts, { depth: null });
+
+    await sleep(2000);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+testAsymmetricParallelTools();

package/src/scripts/parallel-full-metadata-test.ts

@@ -0,0 +1,240 @@
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { Providers, GraphEvents } from '@/common';
+import { sleep } from '@/utils/run';
+import { Run } from '@/run';
+import { Calculator } from '@/tools/Calculator';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Dump ALL metadata fields to understand what LangSmith uses
+ * to detect parallel execution
+ */
+async function testFullMetadata() {
+  console.log('Dumping FULL metadata to find parallel detection fields...\n');
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Collect ALL metadata from all events
+  const allMetadata: Array<{
+    event: string;
+    timestamp: number;
+    metadata: Record<string, unknown>;
+  }> = [];
+  const startTime = Date.now();
+
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'agent_a',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are Agent A. Just say "Hello from A" in one sentence.`,
+    },
+    {
+      agentId: 'agent_b',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      tools: [new Calculator()],
+      instructions: `You are Agent B. Calculate 2+2 using the calculator tool.`,
+    },
+  ];
+
+  const edges: t.GraphEdge[] = [];
+
+  const captureMetadata = (
+    eventName: string,
+    metadata?: Record<string, unknown>
+  ) => {
+    if (metadata) {
+      allMetadata.push({
+        event: eventName,
+        timestamp: Date.now() - startTime,
+        metadata: { ...metadata },
+      });
+    }
+  };
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('TOOL_END', metadata);
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('TOOL_START', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_END]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('CHAT_MODEL_END', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_START]: {
+      handle: (
+        _event: string,
+        _data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('CHAT_MODEL_START', metadata);
+      },
+    },
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('ON_RUN_STEP', metadata);
+        const runStep = data as t.RunStep;
+        console.log(
+          `\n🔍 ON_RUN_STEP: agentId=${runStep.agentId}, groupId=${runStep.groupId}`
+        );
+        aggregateContent({ event, data: runStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('ON_RUN_STEP_DELTA', metadata);
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        captureMetadata('ON_MESSAGE_DELTA', metadata);
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+  };
+
+  const runConfig: t.RunConfig = {
+    runId: `full-metadata-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    const run = await Run.create(runConfig);
+
+    const userMessage = `Hi, and calculate 2+2`;
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const config = {
+      configurable: {
+        thread_id: 'full-metadata-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    await run.processStream({ messages: conversationHistory }, config);
+
+    // Analysis - find ALL unique metadata keys
+    console.log('\n\n========== ALL UNIQUE METADATA KEYS ==========\n');
+    const allKeys = new Set<string>();
+    for (const entry of allMetadata) {
+      for (const key of Object.keys(entry.metadata)) {
+        allKeys.add(key);
+      }
+    }
+    console.log('Keys found:', [...allKeys].sort());
+
+    // Print first CHAT_MODEL_START for each agent with FULL metadata
+    console.log(
+      '\n\n========== FULL METADATA FROM CHAT_MODEL_START ==========\n'
+    );
+    const seenAgents = new Set<string>();
+    for (const entry of allMetadata) {
+      if (entry.event === 'CHAT_MODEL_START') {
+        const node = entry.metadata.langgraph_node as string;
+        if (!seenAgents.has(node)) {
+          seenAgents.add(node);
+          console.log(`\n--- ${node} ---`);
+          console.dir(entry.metadata, { depth: null });
+        }
+      }
+    }
+
+    // Look specifically at checkpoint_ns and __pregel_task_id
+    console.log('\n\n========== POTENTIAL PARALLEL INDICATORS ==========\n');
+    console.log(
+      'Comparing checkpoint_ns and __pregel_task_id across agents:\n'
+    );
+
+    const agentMetadataMap = new Map<string, Record<string, unknown>>();
+    for (const entry of allMetadata) {
+      if (entry.event === 'CHAT_MODEL_START') {
+        const node = entry.metadata.langgraph_node as string;
+        if (!agentMetadataMap.has(node)) {
+          agentMetadataMap.set(node, entry.metadata);
+        }
+      }
+    }
+
+    for (const [node, meta] of agentMetadataMap) {
+      console.log(`${node}:`);
+      console.log(`  langgraph_step: ${meta.langgraph_step}`);
+      console.log(
+        `  langgraph_triggers: ${JSON.stringify(meta.langgraph_triggers)}`
+      );
+      console.log(`  checkpoint_ns: ${meta.checkpoint_ns}`);
+      console.log(`  __pregel_task_id: ${meta.__pregel_task_id}`);
+      console.log(`  langgraph_path: ${JSON.stringify(meta.langgraph_path)}`);
+      console.log(`  langgraph_checkpoint_ns: ${meta.langgraph_checkpoint_ns}`);
+      console.log();
+    }
+
+    // Check langgraph_triggers specifically
+    console.log('\n========== LANGGRAPH_TRIGGERS ANALYSIS ==========\n');
+    for (const [node, meta] of agentMetadataMap) {
+      const triggers = meta.langgraph_triggers as string[];
+      console.log(`${node}: triggers = ${JSON.stringify(triggers)}`);
+    }
+
+    console.log('\n\nFinal content parts:');
+    console.dir(contentParts, { depth: null });
+
+    await sleep(1000);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+testFullMetadata();