illuma-agents 1.0.27 → 1.0.28

package/src/graphs/Graph.ts

@@ -1246,6 +1246,26 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
     return workflow;
   }
 
+  /**
+   * Indicates if this is a multi-agent graph.
+   * Override in MultiAgentGraph to return true.
+   * Used to conditionally include agentId in RunStep for frontend rendering.
+   */
+  protected isMultiAgentGraph(): boolean {
+    return false;
+  }
+
+  /**
+   * Get the parallel group ID for an agent, if any.
+   * Override in MultiAgentGraph to provide actual group IDs.
+   * Group IDs are incrementing numbers (1, 2, 3...) reflecting execution order.
+   * @param _agentId - The agent ID to look up
+   * @returns undefined for StandardGraph (no parallel groups), or group number for MultiAgentGraph
+   */
+  protected getParallelGroupIdForAgent(_agentId: string): number | undefined {
+    return undefined;
+  }
+
   /* Dispatchers */
 
   /**
@@ -1286,13 +1306,21 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
     }
 
     /**
-     * Extract and store agentId from metadata
+     * Extract agentId and parallelGroupId from metadata
+     * Only set agentId for MultiAgentGraph (so frontend knows when to show agent labels)
      */
     if (metadata) {
       try {
         const agentContext = this.getAgentContext(metadata);
-        if (agentContext.agentId) {
+        if (this.isMultiAgentGraph() && agentContext.agentId) {
+          // Only include agentId for MultiAgentGraph - enables frontend to show agent labels
           runStep.agentId = agentContext.agentId;
+          // Set group ID if this agent is part of a parallel group
+          // Group IDs are incrementing numbers (1, 2, 3...) reflecting execution order
+          const groupId = this.getParallelGroupIdForAgent(agentContext.agentId);
+          if (groupId != null) {
+            runStep.groupId = groupId;
+          }
         }
       } catch (_e) {
         /** If we can't get agent context, that's okay - agentId remains undefined */

package/src/graphs/MultiAgentGraph.ts

@@ -40,6 +40,17 @@ export class MultiAgentGraph extends StandardGraph {
   private startingNodes: Set<string> = new Set();
   private directEdges: t.GraphEdge[] = [];
   private handoffEdges: t.GraphEdge[] = [];
+  /**
+   * Map of agentId to parallel group info.
+   * Contains groupId (incrementing number reflecting execution order) for agents in parallel groups.
+   * Sequential agents (not in any parallel group) have undefined entry.
+   *
+   * Example for: researcher -> [analyst1, analyst2, analyst3] -> summarizer
+   * - researcher: undefined (sequential, order 0)
+   * - analyst1, analyst2, analyst3: { groupId: 1 } (parallel group, order 1)
+   * - summarizer: undefined (sequential, order 2)
+   */
+  private agentParallelGroups: Map<string, number> = new Map();
 
   constructor(input: t.MultiAgentGraphInput) {
     super(input);
@@ -99,6 +110,114 @@ export class MultiAgentGraph extends StandardGraph {
     if (this.startingNodes.size === 0 && this.agentContexts.size > 0) {
       this.startingNodes.add(this.agentContexts.keys().next().value!);
     }
+
+    // Determine if graph has parallel execution capability
+    this.computeParallelCapability();
+  }
+
+  /**
+   * Compute parallel groups by traversing the graph in execution order.
+   * Assigns incrementing group IDs that reflect the sequential order of execution.
+   *
+   * For: researcher -> [analyst1, analyst2, analyst3] -> summarizer
+   * - researcher: no group (first sequential node)
+   * - analyst1, analyst2, analyst3: groupId 1 (first parallel group)
+   * - summarizer: no group (next sequential node)
+   *
+   * This allows frontend to render in order:
+   * Row 0: researcher
+   * Row 1: [analyst1, analyst2, analyst3] (grouped)
+   * Row 2: summarizer
+   */
+  private computeParallelCapability(): void {
+    let groupCounter = 1; // Start at 1, 0 reserved for "no group"
+
+    // Check 1: Multiple starting nodes means parallel from the start (group 1)
+    if (this.startingNodes.size > 1) {
+      for (const agentId of this.startingNodes) {
+        this.agentParallelGroups.set(agentId, groupCounter);
+      }
+      groupCounter++;
+    }
+
+    // Check 2: Traverse direct edges in order to find fan-out patterns
+    // Build a simple execution order by following edges from starting nodes
+    const visited = new Set<string>();
+    const queue: string[] = [...this.startingNodes];
+
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      if (visited.has(current)) continue;
+      visited.add(current);
+
+      // Find direct edges from this node
+      for (const edge of this.directEdges) {
+        const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
+        if (!sources.includes(current)) continue;
+
+        const destinations = Array.isArray(edge.to) ? edge.to : [edge.to];
+
+        // Fan-out: multiple destinations = parallel group
+        if (destinations.length > 1) {
+          for (const dest of destinations) {
+            // Only set if not already in a group (first group wins)
+            if (!this.agentParallelGroups.has(dest)) {
+              this.agentParallelGroups.set(dest, groupCounter);
+            }
+            if (!visited.has(dest)) {
+              queue.push(dest);
+            }
+          }
+          groupCounter++;
+        } else {
+          // Single destination - add to queue for traversal
+          for (const dest of destinations) {
+            if (!visited.has(dest)) {
+              queue.push(dest);
+            }
+          }
+        }
+      }
+
+      // Also follow handoff edges for traversal (but they don't create parallel groups)
+      for (const edge of this.handoffEdges) {
+        const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
+        if (!sources.includes(current)) continue;
+
+        const destinations = Array.isArray(edge.to) ? edge.to : [edge.to];
+        for (const dest of destinations) {
+          if (!visited.has(dest)) {
+            queue.push(dest);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Get the parallel group ID for an agent, if any.
+   * Returns undefined if the agent is not part of a parallel group.
+   * Group IDs are incrementing numbers reflecting execution order.
+   */
+  getParallelGroupId(agentId: string): number | undefined {
+    return this.agentParallelGroups.get(agentId);
+  }
+
+  /**
+   * Override to indicate this is a multi-agent graph.
+   * Enables agentId to be included in RunStep for frontend agent labeling.
+   */
+  protected override isMultiAgentGraph(): boolean {
+    return true;
+  }
+
+  /**
+   * Override base class method to provide parallel group IDs for run steps.
+   */
+  protected override getParallelGroupIdForAgent(
+    agentId: string
+  ): number | undefined {
+    return this.agentParallelGroups.get(agentId);
   }
 
   /**

package/src/messages/format.ts

@@ -636,7 +636,7 @@ export const labelContentByAgent = (
  */
 export const formatAgentMessages = (
   payload: TPayload,
-  indexTokenCountMap?: Record<number, number>,
+  indexTokenCountMap?: Record<number, number | undefined>,
   tools?: Set<string>
 ): {
   messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
@@ -648,7 +648,7 @@ export const formatAgentMessages = (
   // If indexTokenCountMap is provided, create a new map to track the updated indices
   const updatedIndexTokenCountMap: Record<number, number> = {};
   // Keep track of the mapping from original payload indices to result indices
-  const indexMapping: Record<number, number[]> = {};
+  const indexMapping: Record<number, number[] | undefined> = {};
 
   // Process messages with tool conversion if tools set is provided
   for (let i = 0; i < payload.length; i++) {

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

@@ -143,18 +143,49 @@ async function testSequentialAgentChain() {
 
   // Track agent progression
   let currentAgent = '';
+  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;
+        console.log(`⏱️  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;
+        console.log(`⏱️  STARTED at ${elapsed}ms`);
+      },
+    },
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
         const runStepData = data as any;
+        console.log('\n====== ON_RUN_STEP ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
         if (runStepData?.name) {
           currentAgent = runStepData.name;
           console.log(`\n→ ${currentAgent} is processing...`);
@@ -165,9 +196,15 @@ async function testSequentialAgentChain() {
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
         event: GraphEvents.ON_RUN_STEP_COMPLETED,
-        data: t.StreamEventData
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
       ): void => {
         const runStepData = data as any;
+        console.log('\n====== ON_RUN_STEP_COMPLETED ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        console.log('METADATA:');
+        console.dir(metadata, { depth: null });
         if (runStepData?.name) {
           console.log(`✓ ${runStepData.name} completed`);
         }
@@ -180,16 +217,32 @@ async function testSequentialAgentChain() {
     [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 => {
+        messageCount++;
+        // Only log first few message deltas to avoid spam
+        if (messageCount <= 3) {
+          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-parallel-start.ts

@@ -0,0 +1,265 @@
+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 { Providers, GraphEvents } from '@/common';
+import { sleep } from '@/utils/run';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of parallel multi-agent system that starts with parallel execution immediately
+ *
+ * Graph structure:
+ * START -> [analyst1, analyst2] -> END (parallel from start, both run simultaneously)
+ *
+ * This demonstrates getting a parallel stream from the very beginning,
+ * with two agents running simultaneously. Useful for testing how different
+ * models respond to the same input.
+ */
+async function testParallelFromStart() {
+  console.log('Testing Parallel From Start Multi-Agent System...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent, contentMetadataMap } =
+    createContentAggregator();
+
+  // Define two agents - both have NO incoming edges, so they run in parallel from the start
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'analyst1',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a CREATIVE ANALYST. Analyze the user's query from a creative and innovative perspective. Focus on novel ideas, unconventional approaches, and imaginative possibilities. Keep your response concise (100-150 words). Start with "🎨 CREATIVE:"`,
+    },
+    {
+      agentId: 'analyst2',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-haiku-4-5',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a PRACTICAL ANALYST. Analyze the user's query from a logical and practical perspective. Focus on feasibility, metrics, and actionable steps. Keep your response concise (100-150 words). Start with "📊 PRACTICAL:"`,
+    },
+  ];
+
+  // No edges needed - both agents have no incoming edges, so both are start nodes
+  // They will run in parallel and end when both complete
+  const edges: t.GraphEdge[] = [];
+
+  // Track which agents are active and their timing
+  const activeAgents = new Set<string>();
+  const agentTimings: Record<string, { start?: number; end?: number }> = {};
+  const startTime = Date.now();
+
+  // Create custom handlers with extensive metadata logging
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [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 nodeName = metadata?.langgraph_node as string;
+        if (nodeName) {
+          const elapsed = Date.now() - startTime;
+          agentTimings[nodeName] = agentTimings[nodeName] || {};
+          agentTimings[nodeName].end = elapsed;
+          console.log(`⏱️  [${nodeName}] 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 nodeName = metadata?.langgraph_node as string;
+        if (nodeName) {
+          const elapsed = Date.now() - startTime;
+          agentTimings[nodeName] = agentTimings[nodeName] || {};
+          agentTimings[nodeName].start = elapsed;
+          activeAgents.add(nodeName);
+          console.log(`⏱️  [${nodeName}] 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,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('\n====== ON_RUN_STEP_COMPLETED ======');
+        console.log('DATA:');
+        console.dir(data, { depth: null });
+        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('\n====== 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,
+        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,
+        metadata?: Record<string, unknown>
+      ): void => {
+        // Only log first delta per agent to avoid spam
+        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 });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `parallel-start-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    // Debug: Log the graph structure
+    console.log('=== DEBUG: Graph Structure ===');
+    const graph = (run as any).Graph;
+    console.log('Graph exists:', !!graph);
+    if (graph) {
+      console.log('Graph type:', graph.constructor.name);
+      console.log('AgentContexts exists:', !!graph.agentContexts);
+      if (graph.agentContexts) {
+        console.log('AgentContexts size:', graph.agentContexts.size);
+        for (const [agentId, context] of graph.agentContexts) {
+          console.log(`\nAgent: ${agentId}`);
+          console.log(
+            `Tools: ${context.tools?.map((t: any) => t.name || 'unnamed').join(', ') || 'none'}`
+          );
+        }
+      }
+    }
+    console.log('=== END DEBUG ===\n');
+
+    const userMessage = `What are the best approaches to learning a new programming language?`;
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log('Invoking parallel-from-start multi-agent graph...\n');
+    console.log('Both analyst1 and analyst2 should start simultaneously!\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'parallel-start-conversation-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========== TIMING SUMMARY ==========');
+    for (const [agent, timing] of Object.entries(agentTimings)) {
+      const duration =
+        timing.end && timing.start ? timing.end - timing.start : 'N/A';
+      console.log(
+        `${agent}: started=${timing.start}ms, ended=${timing.end}ms, duration=${duration}ms`
+      );
+    }
+
+    // Check if parallel
+    const agents = Object.keys(agentTimings);
+    if (agents.length >= 2) {
+      const [a1, a2] = agents;
+      const t1 = agentTimings[a1];
+      const t2 = agentTimings[a2];
+      if (t1.start && t2.start && t1.end && t2.end) {
+        const overlap = Math.min(t1.end, t2.end) - Math.max(t1.start, t2.start);
+        if (overlap > 0) {
+          console.log(
+            `\n✅ PARALLEL EXECUTION CONFIRMED: ${overlap}ms overlap`
+          );
+        } else {
+          console.log(`\n❌ SEQUENTIAL EXECUTION: no overlap`);
+        }
+      }
+    }
+    console.log('====================================\n');
+
+    console.log('Final content parts:', contentParts.length, 'parts');
+    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 });
+
+    await sleep(3000);
+  } catch (error) {
+    console.error('Error in parallel-from-start multi-agent test:', error);
+  }
+}
+
+// Run the test
+testParallelFromStart();

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 });
       },
     },