@illuma-ai/agents 1.1.14 → 1.1.16

package/src/graphs/__tests__/multi-agent-delegate.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Unit tests for the handoff pattern (supervisor-delegate) in MultiAgentGraph.
+ *
+ * Tests cover:
+ * - Result extraction from child agent messages (extractHandoffResult)
+ * - Result truncation for parent context protection (truncateHandoffResult)
+ * - Constants and naming conventions
+ */
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import {
+  Constants,
+  EdgeType,
+  DEFAULT_HANDOFF_MAX_RESULT_CHARS,
+  HANDOFF_TIMEOUT_MS,
+} from '@/common';
+
+/**
+ * Import the static helper methods from MultiAgentGraph.
+ * These are static so they can be tested without instantiating the full graph.
+ */
+import { MultiAgentGraph } from '../MultiAgentGraph';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+describe('handoff constants', () => {
+  it('LC_HANDOFF_TO_ prefix matches expected pattern', () => {
+    expect(Constants.LC_HANDOFF_TO_).toBe('lc_handoff_to_');
+  });
+
+  it('LC_HANDOFF_TO_ is distinct from LC_TRANSFER_TO_', () => {
+    expect(Constants.LC_HANDOFF_TO_).not.toBe(Constants.LC_TRANSFER_TO_);
+  });
+
+  it('DEFAULT_HANDOFF_MAX_RESULT_CHARS is 32768', () => {
+    expect(DEFAULT_HANDOFF_MAX_RESULT_CHARS).toBe(32768);
+  });
+
+  it('HANDOFF_TIMEOUT_MS is 5 minutes', () => {
+    expect(HANDOFF_TIMEOUT_MS).toBe(300_000);
+  });
+
+  it('EdgeType.HANDOFF has correct value', () => {
+    expect(EdgeType.HANDOFF).toBe('handoff');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// extractHandoffResult
+// ---------------------------------------------------------------------------
+describe('extractHandoffResult', () => {
+  it('extracts text from last AIMessage with string content', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('find sales data'),
+      new AIMessage('Here are the sales figures for Q1...'),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'researcher');
+    expect(result).toBe('Here are the sales figures for Q1...');
+  });
+
+  it('extracts text from last AIMessage with array content', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('analyze this'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Analysis shows growth.' },
+          { type: 'text', text: 'Revenue up 15%.' },
+        ],
+      }),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'analyst');
+    expect(result).toBe('Analysis shows growth.\nRevenue up 15%.');
+  });
+
+  it('skips non-AI messages and finds last AIMessage', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('task'),
+      new AIMessage('intermediate result'),
+      new HumanMessage('continue'),
+      new AIMessage('final result here'),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
+    expect(result).toBe('final result here');
+  });
+
+  it('skips AIMessages with empty content and finds previous', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('task'),
+      new AIMessage('good result'),
+      new AIMessage(''),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
+    expect(result).toBe('good result');
+  });
+
+  it('skips AIMessages with tool_calls only (no text)', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('task'),
+      new AIMessage('found the data'),
+      new AIMessage({
+        content: '',
+        tool_calls: [{ name: 'search', args: {}, id: 'tc1', type: 'tool_call' }],
+      }),
+      new ToolMessage({ content: 'search result', tool_call_id: 'tc1' }),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
+    expect(result).toBe('found the data');
+  });
+
+  it('returns fallback message when no AIMessage has text', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('task'),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'researcher');
+    expect(result).toBe('[Agent "researcher" completed but produced no text output]');
+  });
+
+  it('returns fallback for empty messages array', () => {
+    const result = MultiAgentGraph.extractHandoffResult([], 'agent');
+    expect(result).toBe('[Agent "agent" completed but produced no text output]');
+  });
+
+  it('trims whitespace from extracted text', () => {
+    const messages: BaseMessage[] = [
+      new AIMessage('  result with spaces  \n\n'),
+    ];
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
+    expect(result).toBe('result with spaces');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// truncateHandoffResult
+// ---------------------------------------------------------------------------
+describe('truncateHandoffResult', () => {
+  it('returns result unchanged when within budget', () => {
+    const result = 'short result';
+    expect(MultiAgentGraph.truncateHandoffResult(result, 1000)).toBe(result);
+  });
+
+  it('returns empty string unchanged', () => {
+    expect(MultiAgentGraph.truncateHandoffResult('', 1000)).toBe('');
+  });
+
+  it('truncates with head/tail split when over budget', () => {
+    const longText = 'A'.repeat(1000);
+    const truncated = MultiAgentGraph.truncateHandoffResult(longText, 500);
+
+    expect(truncated.length).toBeLessThanOrEqual(500);
+    expect(truncated).toContain('handoff output truncated');
+    // Head should be present
+    expect(truncated.startsWith('AAAA')).toBe(true);
+    // Tail should be present
+    expect(truncated.endsWith('AAAA')).toBe(true);
+  });
+
+  it('preserves 60/40 head/tail ratio', () => {
+    const longText = 'H'.repeat(500) + 'T'.repeat(500);
+    const maxChars = 200;
+    const truncated = MultiAgentGraph.truncateHandoffResult(longText, maxChars);
+
+    const notice = '\n\n[... handoff output truncated — middle section omitted to fit parent context ...]\n\n';
+    const available = maxChars - notice.length;
+    const expectedHead = Math.floor(available * 0.6);
+    const expectedTail = available - expectedHead;
+
+    // Head portion should be all H's
+    const headPortion = truncated.substring(0, expectedHead);
+    expect(headPortion).toMatch(/^H+$/);
+
+    // Tail portion should be all T's
+    const tailPortion = truncated.substring(truncated.length - expectedTail);
+    expect(tailPortion).toMatch(/^T+$/);
+  });
+
+  it('handles result exactly at maxChars boundary', () => {
+    const result = 'X'.repeat(100);
+    expect(MultiAgentGraph.truncateHandoffResult(result, 100)).toBe(result);
+  });
+
+  it('handles very small maxChars gracefully', () => {
+    const result = 'A'.repeat(200);
+    // When maxChars is smaller than the truncation notice itself
+    const truncated = MultiAgentGraph.truncateHandoffResult(result, 10);
+    expect(truncated.length).toBeLessThanOrEqual(200);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tool naming convention
+// ---------------------------------------------------------------------------
+describe('handoff tool naming', () => {
+  it('handoff tool name follows lc_handoff_to_ pattern', () => {
+    const agentId = 'researcher_agent_123';
+    const expectedToolName = `${Constants.LC_HANDOFF_TO_}${agentId}`;
+    expect(expectedToolName).toBe('lc_handoff_to_researcher_agent_123');
+  });
+
+  it('handoff tool prefix is distinct from transfer tool prefix', () => {
+    const agentId = 'test';
+    const handoffName = `${Constants.LC_HANDOFF_TO_}${agentId}`;
+    const transferName = `${Constants.LC_TRANSFER_TO_}${agentId}`;
+    expect(handoffName).not.toBe(transferName);
+    expect(handoffName).toBe('lc_handoff_to_test');
+    expect(transferName).toBe('lc_transfer_to_test');
+  });
+});

package/src/graphs/__tests__/multi-agent-edges.test.ts

@@ -3,11 +3,11 @@
  * and parallel group computation in MultiAgentGraph.
  *
  * These test the edge classification rules without instantiating the full graph:
- * - Explicit EdgeType.HANDOFF → handoff
- * - Explicit EdgeType.DIRECT → direct
- * - Condition-based edges → handoff (always, regardless of edgeType)
- * - Default single→single → handoff
- * - Default single→many → direct (fan-out pattern)
+ * - Explicit EdgeType.TRANSFER → transfer
+ * - Explicit EdgeType.SEQUENCE → sequence
+ * - Condition-based edges → transfer (always, regardless of edgeType)
+ * - Default single→single → transfer
+ * - Default single→many → sequence (fan-out pattern)
  */
 import { EdgeType } from '@/common';
 import type { GraphEdge, BaseGraphState } from '@/types';
@@ -17,30 +17,34 @@ import type { GraphEdge, BaseGraphState } from '@/types';
  * Kept in sync with the private method for testability.
  */
 function categorizeEdges(edges: GraphEdge[]): {
-  directEdges: GraphEdge[];
+  sequenceEdges: GraphEdge[];
+  transferEdges: GraphEdge[];
   handoffEdges: GraphEdge[];
 } {
-  const directEdges: GraphEdge[] = [];
+  const sequenceEdges: GraphEdge[] = [];
+  const transferEdges: GraphEdge[] = [];
   const handoffEdges: GraphEdge[] = [];
 
   for (const edge of edges) {
-    if (edge.edgeType === EdgeType.DIRECT) {
-      directEdges.push(edge);
-    } else if (edge.edgeType === EdgeType.HANDOFF || edge.condition != null) {
+    if (edge.edgeType === EdgeType.HANDOFF) {
       handoffEdges.push(edge);
+    } else if (edge.edgeType === EdgeType.SEQUENCE) {
+      sequenceEdges.push(edge);
+    } else if (edge.edgeType === EdgeType.TRANSFER || edge.condition != null) {
+      transferEdges.push(edge);
     } else {
       const destinations = Array.isArray(edge.to) ? edge.to : [edge.to];
       const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
 
       if (sources.length === 1 && destinations.length > 1) {
-        directEdges.push(edge);
+        sequenceEdges.push(edge);
       } else {
-        handoffEdges.push(edge);
+        transferEdges.push(edge);
       }
     }
   }
 
-  return { directEdges, handoffEdges };
+  return { sequenceEdges, transferEdges, handoffEdges };
 }
 
 /**
@@ -75,84 +79,115 @@ function findStartingNodes(
 // Edge categorization
 // ---------------------------------------------------------------------------
 describe('edge categorization', () => {
-  it('classifies explicit EdgeType.HANDOFF as handoff', () => {
+  it('classifies explicit EdgeType.TRANSFER as transfer', () => {
     const edges: GraphEdge[] = [
-      { from: 'a', to: 'b', edgeType: EdgeType.HANDOFF },
+      { from: 'a', to: 'b', edgeType: EdgeType.TRANSFER },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(handoffEdges).toHaveLength(1);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(0);
   });
 
-  it('classifies explicit EdgeType.DIRECT as direct', () => {
+  it('classifies explicit EdgeType.SEQUENCE as sequence', () => {
     const edges: GraphEdge[] = [
-      { from: 'a', to: 'b', edgeType: EdgeType.DIRECT },
+      { from: 'a', to: 'b', edgeType: EdgeType.SEQUENCE },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(directEdges).toHaveLength(1);
-    expect(handoffEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(sequenceEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(0);
   });
 
-  it('classifies condition-based edges as handoff regardless of edgeType', () => {
+  it('classifies condition-based edges as transfer regardless of edgeType', () => {
     const condition = (_state: BaseGraphState) => true;
     const edges: GraphEdge[] = [
       { from: 'a', to: 'b', condition },
-      { from: 'c', to: 'd', condition, edgeType: EdgeType.HANDOFF },
+      { from: 'c', to: 'd', condition, edgeType: EdgeType.TRANSFER },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(handoffEdges).toHaveLength(2);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(transferEdges).toHaveLength(2);
+    expect(sequenceEdges).toHaveLength(0);
   });
 
-  it('defaults single→single edges to handoff', () => {
+  it('defaults single→single edges to transfer', () => {
     const edges: GraphEdge[] = [{ from: 'supervisor', to: 'worker' }];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(handoffEdges).toHaveLength(1);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(0);
   });
 
-  it('defaults single→many edges to direct (fan-out pattern)', () => {
+  it('defaults single→many edges to sequence (fan-out pattern)', () => {
     const edges: GraphEdge[] = [
       { from: 'coordinator', to: ['analyst1', 'analyst2', 'analyst3'] },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(directEdges).toHaveLength(1);
-    expect(handoffEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(sequenceEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(0);
   });
 
-  it('defaults many→single edges to handoff', () => {
+  it('defaults many→single edges to transfer', () => {
     const edges: GraphEdge[] = [
       { from: ['analyst1', 'analyst2'], to: 'summarizer' },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(handoffEdges).toHaveLength(1);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(0);
   });
 
   it('correctly categorizes a mixed set of edges', () => {
     const edges: GraphEdge[] = [
-      // Explicit direct: sequential chain
-      { from: 'researcher', to: 'analyst', edgeType: EdgeType.DIRECT },
-      // Fan-out: defaults to direct
+      // Explicit sequence: sequential chain
+      { from: 'researcher', to: 'analyst', edgeType: EdgeType.SEQUENCE },
+      // Fan-out: defaults to sequence
       { from: 'analyst', to: ['reviewer1', 'reviewer2'] },
-      // Explicit handoff: dynamic routing
-      { from: 'supervisor', to: 'specialist', edgeType: EdgeType.HANDOFF },
-      // Default single→single: handoff
+      // Explicit transfer: dynamic routing
+      { from: 'supervisor', to: 'specialist', edgeType: EdgeType.TRANSFER },
+      // Default single→single: transfer
       { from: 'triage', to: 'handler' },
-      // Condition-based: always handoff
+      // Condition-based: always transfer
       { from: 'router', to: 'a', condition: () => true },
     ];
 
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(directEdges).toHaveLength(2); // explicit direct + fan-out
-    expect(handoffEdges).toHaveLength(3); // explicit handoff + default single→single + condition
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(sequenceEdges).toHaveLength(2); // explicit sequence + fan-out
+    expect(transferEdges).toHaveLength(3); // explicit transfer + default single→single + condition
   });
 
   it('handles empty edges array', () => {
-    const { directEdges, handoffEdges } = categorizeEdges([]);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges([]);
+    expect(sequenceEdges).toHaveLength(0);
+    expect(transferEdges).toHaveLength(0);
     expect(handoffEdges).toHaveLength(0);
   });
+
+  it('classifies explicit EdgeType.HANDOFF as handoff', () => {
+    const edges: GraphEdge[] = [
+      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.HANDOFF },
+    ];
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges(edges);
+    expect(handoffEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(0);
+    expect(sequenceEdges).toHaveLength(0);
+  });
+
+  it('supports mixed transfer, sequence, and handoff edges from same source', () => {
+    const edges: GraphEdge[] = [
+      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.HANDOFF },
+      { from: 'supervisor', to: 'writer', edgeType: EdgeType.TRANSFER },
+      { from: 'supervisor', to: 'formatter', edgeType: EdgeType.SEQUENCE },
+    ];
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges(edges);
+    expect(handoffEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(1);
+  });
+
+  it('categorization works with handoff string value cast as EdgeType', () => {
+    const edges: GraphEdge[] = [
+      { from: 'a', to: 'b', edgeType: 'handoff' as EdgeType },
+    ];
+    const { handoffEdges } = categorizeEdges(edges);
+    expect(handoffEdges).toHaveLength(1);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -215,23 +250,25 @@ describe('starting node identification', () => {
 // ---------------------------------------------------------------------------
 describe('EdgeType values match GraphEdge string literals', () => {
   it('HANDOFF matches the string used in MongoDB documents', () => {
-    // ranger stores edges in MongoDB with string values
-    // This ensures the enum stays compatible
     expect(EdgeType.HANDOFF).toBe('handoff');
   });
 
-  it('DIRECT matches the string used in MongoDB documents', () => {
-    expect(EdgeType.DIRECT).toBe('direct');
+  it('TRANSFER matches the string used in MongoDB documents', () => {
+    expect(EdgeType.TRANSFER).toBe('transfer');
+  });
+
+  it('SEQUENCE matches the string used in MongoDB documents', () => {
+    expect(EdgeType.SEQUENCE).toBe('sequence');
   });
 
   it('categorization works with string values cast as EdgeType', () => {
     // Simulates data coming from MongoDB where edgeType is stored as string
     const edges: GraphEdge[] = [
-      { from: 'a', to: 'b', edgeType: 'handoff' as EdgeType },
-      { from: 'c', to: 'd', edgeType: 'direct' as EdgeType },
+      { from: 'a', to: 'b', edgeType: 'transfer' as EdgeType },
+      { from: 'c', to: 'd', edgeType: 'sequence' as EdgeType },
     ];
-    const { directEdges, handoffEdges } = categorizeEdges(edges);
-    expect(handoffEdges).toHaveLength(1);
-    expect(directEdges).toHaveLength(1);
+    const { sequenceEdges, transferEdges } = categorizeEdges(edges);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(1);
   });
 });

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

@@ -19,7 +19,7 @@ function createSequentialChainEdges(agentIds) {
         edges.push({
             from: fromAgent,
             to: toAgent,
-            edgeType: 'direct',
+            edgeType: 'sequence',
             // Use a prompt function to create the buffer string from all previous results
             prompt: (messages, startIndex) => {
                 // Get only the messages from this run (after startIndex)

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

@@ -28,7 +28,7 @@ function createSequentialChainEdges(agentIds: string[]): t.GraphEdge[] {
     edges.push({
       from: fromAgent,
       to: toAgent,
-      edgeType: 'direct',
+      edgeType: 'sequence',
       // 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)

package/src/scripts/multi-agent-document-review-chain.js

@@ -13,7 +13,7 @@ function createDocumentReviewChain(agentIds) {
         edges.push({
             from: agentIds[i],
             to: agentIds[i + 1],
-            edgeType: 'direct',
+            edgeType: 'sequence',
             prompt: (messages, startIndex) => {
                 const runMessages = messages.slice(startIndex);
                 const bufferString = getBufferString(runMessages);

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

@@ -22,7 +22,7 @@ function createDocumentReviewChain(agentIds: string[]): t.GraphEdge[] {
     edges.push({
       from: agentIds[i],
       to: agentIds[i + 1],
-      edgeType: 'direct',
+      edgeType: 'sequence',
       prompt: (messages: BaseMessage[], startIndex: number) => {
         const runMessages = messages.slice(startIndex);
         const bufferString = getBufferString(runMessages);

package/src/scripts/multi-agent-hybrid-flow.js

@@ -102,7 +102,7 @@ async function testHybridMultiAgent() {
         {
             from: 'primary_agent',
             to: 'standalone_agent',
-            edgeType: 'handoff',
+            edgeType: 'transfer',
             description: 'Transfer to standalone specialist for complex requests',
             prompt: 'Specific instructions for the specialist',
         },
@@ -110,14 +110,14 @@ async function testHybridMultiAgent() {
         {
             from: 'primary_agent',
             to: 'agent_b',
-            edgeType: 'direct',
+            edgeType: 'sequence',
             description: 'Continue to Agent B only if no handoff occurs',
         },
         // Direct edge: agent_b automatically continues to agent_c
         {
             from: 'agent_b',
             to: 'agent_c',
-            edgeType: 'direct',
+            edgeType: 'sequence',
             description: 'Automatic progression from B to C',
         },
     ];

package/src/scripts/multi-agent-hybrid-flow.ts

@@ -108,7 +108,7 @@ async function testHybridMultiAgent() {
     {
       from: 'primary_agent',
       to: 'standalone_agent',
-      edgeType: 'handoff',
+      edgeType: 'transfer',
       description: 'Transfer to standalone specialist for complex requests',
       prompt: 'Specific instructions for the specialist',
     },
@@ -116,14 +116,14 @@ async function testHybridMultiAgent() {
     {
       from: 'primary_agent',
       to: 'agent_b',
-      edgeType: 'direct',
+      edgeType: 'sequence',
       description: 'Continue to Agent B only if no handoff occurs',
     },
     // Direct edge: agent_b automatically continues to agent_c
     {
       from: 'agent_b',
       to: 'agent_c',
-      edgeType: 'direct',
+      edgeType: 'sequence',
       description: 'Automatic progression from B to C',
     },
   ];

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

@@ -152,13 +152,13 @@ async function testParallelMultiAgent() {
             from: 'researcher',
             to: ['analyst1', 'analyst2', 'analyst3'], // Fan-out to multiple analysts
             description: 'Distribute research to specialist analysts',
-            edgeType: 'direct', // Explicitly set as direct for automatic transition (enables parallel execution)
+            edgeType: 'sequence', // Explicitly set as direct for automatic transition (enables parallel execution)
         },
         {
             from: ['analyst1', 'analyst2', 'analyst3'], // Fan-in from multiple sources
             to: 'summarizer',
             description: 'Aggregate analysis results',
-            edgeType: 'direct', // Fan-in is also direct
+            edgeType: 'sequence', // Fan-in is also direct
             // Add prompt when all analysts have provided input
             // prompt: (messages, runStartIndex) => {
             //   // Check if we have analysis content from all three analysts

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

@@ -160,13 +160,13 @@ async function testParallelMultiAgent() {
       from: 'researcher',
       to: ['analyst1', 'analyst2', 'analyst3'], // Fan-out to multiple analysts
       description: 'Distribute research to specialist analysts',
-      edgeType: 'direct', // Explicitly set as direct for automatic transition (enables parallel execution)
+      edgeType: 'sequence', // Explicitly set as direct for automatic transition (enables parallel execution)
     },
     {
       from: ['analyst1', 'analyst2', 'analyst3'], // Fan-in from multiple sources
       to: 'summarizer',
       description: 'Aggregate analysis results',
-      edgeType: 'direct', // Fan-in is also direct
+      edgeType: 'sequence', // Fan-in is also direct
       // Add prompt when all analysts have provided input
       // prompt: (messages, runStartIndex) => {
       //   // Check if we have analysis content from all three analysts

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

@@ -75,13 +75,13 @@ async function testSequentialMultiAgent() {
         {
             from: 'agent_a',
             to: 'agent_b',
-            edgeType: 'direct', // This creates direct edges without tools
+            edgeType: 'sequence', // This creates direct edges without tools
             description: 'Automatic transition from A to B',
         },
         {
             from: 'agent_b',
             to: 'agent_c',
-            edgeType: 'direct', // This creates direct edges without tools
+            edgeType: 'sequence', // This creates direct edges without tools
             description: 'Automatic transition from B to C',
         },
     ];

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

@@ -82,13 +82,13 @@ async function testSequentialMultiAgent() {
     {
       from: 'agent_a',
       to: 'agent_b',
-      edgeType: 'direct', // This creates direct edges without tools
+      edgeType: 'sequence', // This creates direct edges without tools
       description: 'Automatic transition from A to B',
     },
     {
       from: 'agent_b',
       to: 'agent_c',
-      edgeType: 'direct', // This creates direct edges without tools
+      edgeType: 'sequence', // This creates direct edges without tools
       description: 'Automatic transition from B to C',
     },
   ];

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

@@ -228,31 +228,31 @@ async function testSupervisorMultiAgent() {
                 from: 'supervisor',
                 to: 'data_analyst',
                 description: 'Transfer to data analyst for statistical analysis and metrics',
-                edgeType: 'handoff',
+                edgeType: 'transfer',
             },
             {
                 from: 'supervisor',
                 to: 'security_expert',
                 description: 'Transfer to security expert for cybersecurity assessment',
-                edgeType: 'handoff',
+                edgeType: 'transfer',
             },
             {
                 from: 'supervisor',
                 to: 'product_designer',
                 description: 'Transfer to product designer for UX/UI design',
-                edgeType: 'handoff',
+                edgeType: 'transfer',
             },
             {
                 from: 'supervisor',
                 to: 'devops_engineer',
                 description: 'Transfer to DevOps engineer for infrastructure and deployment',
-                edgeType: 'handoff',
+                edgeType: 'transfer',
             },
             {
                 from: 'supervisor',
                 to: 'legal_advisor',
                 description: 'Transfer to legal advisor for compliance and licensing',
-                edgeType: 'handoff',
+                edgeType: 'transfer',
             },
         ];
         return {