@illuma-ai/agents 1.1.15 → 1.1.16

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

@@ -1,9 +1,9 @@
 /**
- * Unit tests for the delegate pattern in MultiAgentGraph.
+ * Unit tests for the handoff pattern (supervisor-delegate) in MultiAgentGraph.
  *
  * Tests cover:
- * - Result extraction from child agent messages (extractDelegateResult)
- * - Result truncation for parent context protection (truncateDelegateResult)
+ * - 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';
@@ -11,8 +11,8 @@ import type { BaseMessage } from '@langchain/core/messages';
 import {
   Constants,
   EdgeType,
-  DEFAULT_DELEGATE_MAX_RESULT_CHARS,
-  DELEGATE_TIMEOUT_MS,
+  DEFAULT_HANDOFF_MAX_RESULT_CHARS,
+  HANDOFF_TIMEOUT_MS,
 } from '@/common';
 
 /**
@@ -24,38 +24,38 @@ import { MultiAgentGraph } from '../MultiAgentGraph';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-describe('delegate constants', () => {
-  it('LC_DELEGATE_TO_ prefix matches expected pattern', () => {
-    expect(Constants.LC_DELEGATE_TO_).toBe('lc_delegate_to_');
+describe('handoff constants', () => {
+  it('LC_HANDOFF_TO_ prefix matches expected pattern', () => {
+    expect(Constants.LC_HANDOFF_TO_).toBe('lc_handoff_to_');
   });
 
-  it('LC_DELEGATE_TO_ is distinct from LC_TRANSFER_TO_', () => {
-    expect(Constants.LC_DELEGATE_TO_).not.toBe(Constants.LC_TRANSFER_TO_);
+  it('LC_HANDOFF_TO_ is distinct from LC_TRANSFER_TO_', () => {
+    expect(Constants.LC_HANDOFF_TO_).not.toBe(Constants.LC_TRANSFER_TO_);
   });
 
-  it('DEFAULT_DELEGATE_MAX_RESULT_CHARS is 32768', () => {
-    expect(DEFAULT_DELEGATE_MAX_RESULT_CHARS).toBe(32768);
+  it('DEFAULT_HANDOFF_MAX_RESULT_CHARS is 32768', () => {
+    expect(DEFAULT_HANDOFF_MAX_RESULT_CHARS).toBe(32768);
   });
 
-  it('DELEGATE_TIMEOUT_MS is 5 minutes', () => {
-    expect(DELEGATE_TIMEOUT_MS).toBe(300_000);
+  it('HANDOFF_TIMEOUT_MS is 5 minutes', () => {
+    expect(HANDOFF_TIMEOUT_MS).toBe(300_000);
   });
 
-  it('EdgeType.DELEGATE has correct value', () => {
-    expect(EdgeType.DELEGATE).toBe('delegate');
+  it('EdgeType.HANDOFF has correct value', () => {
+    expect(EdgeType.HANDOFF).toBe('handoff');
   });
 });
 
 // ---------------------------------------------------------------------------
-// extractDelegateResult
+// extractHandoffResult
 // ---------------------------------------------------------------------------
-describe('extractDelegateResult', () => {
+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.extractDelegateResult(messages, 'researcher');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'researcher');
     expect(result).toBe('Here are the sales figures for Q1...');
   });
 
@@ -69,7 +69,7 @@ describe('extractDelegateResult', () => {
         ],
       }),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'analyst');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'analyst');
     expect(result).toBe('Analysis shows growth.\nRevenue up 15%.');
   });
 
@@ -80,7 +80,7 @@ describe('extractDelegateResult', () => {
       new HumanMessage('continue'),
       new AIMessage('final result here'),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'agent');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
     expect(result).toBe('final result here');
   });
 
@@ -90,7 +90,7 @@ describe('extractDelegateResult', () => {
       new AIMessage('good result'),
       new AIMessage(''),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'agent');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
     expect(result).toBe('good result');
   });
 
@@ -104,7 +104,7 @@ describe('extractDelegateResult', () => {
       }),
       new ToolMessage({ content: 'search result', tool_call_id: 'tc1' }),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'agent');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
     expect(result).toBe('found the data');
   });
 
@@ -112,12 +112,12 @@ describe('extractDelegateResult', () => {
     const messages: BaseMessage[] = [
       new HumanMessage('task'),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'researcher');
+    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.extractDelegateResult([], 'agent');
+    const result = MultiAgentGraph.extractHandoffResult([], 'agent');
     expect(result).toBe('[Agent "agent" completed but produced no text output]');
   });
 
@@ -125,30 +125,30 @@ describe('extractDelegateResult', () => {
     const messages: BaseMessage[] = [
       new AIMessage('  result with spaces  \n\n'),
     ];
-    const result = MultiAgentGraph.extractDelegateResult(messages, 'agent');
+    const result = MultiAgentGraph.extractHandoffResult(messages, 'agent');
     expect(result).toBe('result with spaces');
   });
 });
 
 // ---------------------------------------------------------------------------
-// truncateDelegateResult
+// truncateHandoffResult
 // ---------------------------------------------------------------------------
-describe('truncateDelegateResult', () => {
+describe('truncateHandoffResult', () => {
   it('returns result unchanged when within budget', () => {
     const result = 'short result';
-    expect(MultiAgentGraph.truncateDelegateResult(result, 1000)).toBe(result);
+    expect(MultiAgentGraph.truncateHandoffResult(result, 1000)).toBe(result);
   });
 
   it('returns empty string unchanged', () => {
-    expect(MultiAgentGraph.truncateDelegateResult('', 1000)).toBe('');
+    expect(MultiAgentGraph.truncateHandoffResult('', 1000)).toBe('');
   });
 
   it('truncates with head/tail split when over budget', () => {
     const longText = 'A'.repeat(1000);
-    const truncated = MultiAgentGraph.truncateDelegateResult(longText, 500);
+    const truncated = MultiAgentGraph.truncateHandoffResult(longText, 500);
 
     expect(truncated.length).toBeLessThanOrEqual(500);
-    expect(truncated).toContain('delegate output truncated');
+    expect(truncated).toContain('handoff output truncated');
     // Head should be present
     expect(truncated.startsWith('AAAA')).toBe(true);
     // Tail should be present
@@ -158,9 +158,9 @@ describe('truncateDelegateResult', () => {
   it('preserves 60/40 head/tail ratio', () => {
     const longText = 'H'.repeat(500) + 'T'.repeat(500);
     const maxChars = 200;
-    const truncated = MultiAgentGraph.truncateDelegateResult(longText, maxChars);
+    const truncated = MultiAgentGraph.truncateHandoffResult(longText, maxChars);
 
-    const notice = '\n\n[... delegate output truncated — middle section omitted to fit parent context ...]\n\n';
+    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;
@@ -176,13 +176,13 @@ describe('truncateDelegateResult', () => {
 
   it('handles result exactly at maxChars boundary', () => {
     const result = 'X'.repeat(100);
-    expect(MultiAgentGraph.truncateDelegateResult(result, 100)).toBe(result);
+    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.truncateDelegateResult(result, 10);
+    const truncated = MultiAgentGraph.truncateHandoffResult(result, 10);
     expect(truncated.length).toBeLessThanOrEqual(200);
   });
 });
@@ -190,19 +190,19 @@ describe('truncateDelegateResult', () => {
 // ---------------------------------------------------------------------------
 // Tool naming convention
 // ---------------------------------------------------------------------------
-describe('delegate tool naming', () => {
-  it('delegate tool name follows lc_delegate_to_ pattern', () => {
+describe('handoff tool naming', () => {
+  it('handoff tool name follows lc_handoff_to_ pattern', () => {
     const agentId = 'researcher_agent_123';
-    const expectedToolName = `${Constants.LC_DELEGATE_TO_}${agentId}`;
-    expect(expectedToolName).toBe('lc_delegate_to_researcher_agent_123');
+    const expectedToolName = `${Constants.LC_HANDOFF_TO_}${agentId}`;
+    expect(expectedToolName).toBe('lc_handoff_to_researcher_agent_123');
   });
 
-  it('delegate tool prefix is distinct from transfer tool prefix', () => {
+  it('handoff tool prefix is distinct from transfer tool prefix', () => {
     const agentId = 'test';
-    const delegateName = `${Constants.LC_DELEGATE_TO_}${agentId}`;
+    const handoffName = `${Constants.LC_HANDOFF_TO_}${agentId}`;
     const transferName = `${Constants.LC_TRANSFER_TO_}${agentId}`;
-    expect(delegateName).not.toBe(transferName);
-    expect(delegateName).toBe('lc_delegate_to_test');
+    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,34 +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[];
-  delegateEdges: GraphEdge[];
 } {
-  const directEdges: GraphEdge[] = [];
+  const sequenceEdges: GraphEdge[] = [];
+  const transferEdges: GraphEdge[] = [];
   const handoffEdges: GraphEdge[] = [];
-  const delegateEdges: GraphEdge[] = [];
 
   for (const edge of edges) {
-    if (edge.edgeType === EdgeType.DELEGATE) {
-      delegateEdges.push(edge);
-    } else 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, delegateEdges };
+  return { sequenceEdges, transferEdges, handoffEdges };
 }
 
 /**
@@ -79,114 +79,114 @@ 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, delegateEdges } = categorizeEdges([]);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges([]);
+    expect(sequenceEdges).toHaveLength(0);
+    expect(transferEdges).toHaveLength(0);
     expect(handoffEdges).toHaveLength(0);
-    expect(delegateEdges).toHaveLength(0);
   });
 
-  it('classifies explicit EdgeType.DELEGATE as delegate', () => {
+  it('classifies explicit EdgeType.HANDOFF as handoff', () => {
     const edges: GraphEdge[] = [
-      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.DELEGATE },
+      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.HANDOFF },
     ];
-    const { directEdges, handoffEdges, delegateEdges } = categorizeEdges(edges);
-    expect(delegateEdges).toHaveLength(1);
-    expect(handoffEdges).toHaveLength(0);
-    expect(directEdges).toHaveLength(0);
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges(edges);
+    expect(handoffEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(0);
+    expect(sequenceEdges).toHaveLength(0);
   });
 
-  it('supports mixed handoff, direct, and delegate edges from same source', () => {
+  it('supports mixed transfer, sequence, and handoff edges from same source', () => {
     const edges: GraphEdge[] = [
-      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.DELEGATE },
-      { from: 'supervisor', to: 'writer', edgeType: EdgeType.HANDOFF },
-      { from: 'supervisor', to: 'formatter', edgeType: EdgeType.DIRECT },
+      { from: 'supervisor', to: 'researcher', edgeType: EdgeType.HANDOFF },
+      { from: 'supervisor', to: 'writer', edgeType: EdgeType.TRANSFER },
+      { from: 'supervisor', to: 'formatter', edgeType: EdgeType.SEQUENCE },
     ];
-    const { directEdges, handoffEdges, delegateEdges } = categorizeEdges(edges);
-    expect(delegateEdges).toHaveLength(1);
+    const { sequenceEdges, transferEdges, handoffEdges } = categorizeEdges(edges);
     expect(handoffEdges).toHaveLength(1);
-    expect(directEdges).toHaveLength(1);
+    expect(transferEdges).toHaveLength(1);
+    expect(sequenceEdges).toHaveLength(1);
   });
 
-  it('categorization works with delegate string value cast as EdgeType', () => {
+  it('categorization works with handoff string value cast as EdgeType', () => {
     const edges: GraphEdge[] = [
-      { from: 'a', to: 'b', edgeType: 'delegate' as EdgeType },
+      { from: 'a', to: 'b', edgeType: 'handoff' as EdgeType },
     ];
-    const { delegateEdges } = categorizeEdges(edges);
-    expect(delegateEdges).toHaveLength(1);
+    const { handoffEdges } = categorizeEdges(edges);
+    expect(handoffEdges).toHaveLength(1);
   });
 });
 
@@ -250,27 +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('DELEGATE matches the string used in MongoDB documents', () => {
-    expect(EdgeType.DELEGATE).toBe('delegate');
+  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',
         },
     ];