@illuma-ai/agents 1.1.20 → 1.1.22

package/src/scripts/test-handoff-steering.js

@@ -1,353 +0,0 @@
-import { config } from 'dotenv';
-config();
-import { HumanMessage } from '@langchain/core/messages';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { GraphEvents, Providers } from '@/common';
-import { Run } from '@/run';
-/**
- * Test LLM steering quality after handoff with system prompt instructions.
- *
- * Validates that the receiving agent clearly understands:
- * 1. WHO it is (its role/identity)
- * 2. WHAT the task is (instructions from the handoff)
- * 3. WHO transferred control (source agent context)
- *
- * Uses specific, verifiable instructions so we can check the output.
- */
-async function testHandoffSteering() {
-    console.log('='.repeat(60));
-    console.log('Test: Handoff Steering Quality (System Prompt Instructions)');
-    console.log('='.repeat(60));
-    const { contentParts, aggregateContent } = createContentAggregator();
-    let currentAgent = '';
-    const agentResponses = {};
-    const customHandlers = {
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data) => {
-                const runStep = data;
-                if (runStep.agentId) {
-                    currentAgent = runStep.agentId;
-                    console.log(`\n[Agent: ${currentAgent}] Processing...`);
-                }
-                aggregateContent({ event, data: runStep });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-            handle: (event, data) => {
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.TOOL_START]: {
-            handle: (_event, data, _metadata) => {
-                const toolData = data;
-                if (toolData?.name?.includes('transfer_to_')) {
-                    const specialist = toolData.name.replace('lc_transfer_to_', '');
-                    console.log(`\n  >> Handoff to: ${specialist}`);
-                }
-            },
-        },
-    };
-    /**
-     * Test 1: Basic handoff with specific task instructions
-     * The specialist should clearly follow the coordinator's instructions.
-     */
-    async function test1_basicInstructions() {
-        console.log('\n' + '-'.repeat(60));
-        console.log('TEST 1: Basic handoff with specific task instructions');
-        console.log('-'.repeat(60));
-        const agents = [
-            {
-                agentId: 'coordinator',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are a Task Coordinator. When a user makes a request:
-1. Analyze what they need
-2. Transfer to the specialist with SPECIFIC instructions about what to do
-
-IMPORTANT: Always use the transfer tool. Do not try to do the work yourself.`,
-                maxContextTokens: 8000,
-            },
-            {
-                agentId: 'specialist',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are a Technical Specialist. You provide detailed technical responses.
-When you receive a task, execute it thoroughly. Always identify yourself as the Technical Specialist in your response.`,
-                maxContextTokens: 8000,
-            },
-        ];
-        const edges = [
-            {
-                from: 'coordinator',
-                to: 'specialist',
-                edgeType: 'transfer',
-                description: 'Transfer to specialist for detailed work',
-                prompt: 'Provide specific instructions for the specialist about what to analyze or create',
-                promptKey: 'instructions',
-            },
-        ];
-        const run = await Run.create({
-            runId: `steering-test1-${Date.now()}`,
-            graphConfig: { type: 'multi-agent', agents, edges },
-            customHandlers,
-            returnContent: true,
-            skipCleanup: true,
-        });
-        const streamConfig = {
-            configurable: { thread_id: 'steering-test1' },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        const query = 'Explain the difference between TCP and UDP. I need exactly 3 bullet points for each protocol.';
-        console.log(`\nQuery: "${query}"\n`);
-        const messages = [new HumanMessage(query)];
-        await run.processStream({ messages }, streamConfig);
-        const finalMessages = run.getRunMessages();
-        console.log('\n--- Specialist Response ---');
-        if (finalMessages) {
-            for (const msg of finalMessages) {
-                if (msg.getType() === 'ai' && typeof msg.content === 'string') {
-                    console.log(msg.content);
-                    agentResponses['test1'] = msg.content;
-                }
-            }
-        }
-        // Check steering quality
-        const response = agentResponses['test1'] || '';
-        const mentionsSpecialist = response.toLowerCase().includes('specialist') ||
-            response.toLowerCase().includes('technical');
-        const hasBulletPoints = (response.match(/[-•*]\s/g) || []).length >= 4 ||
-            (response.match(/\d\./g) || []).length >= 4;
-        const mentionsTCP = response.toLowerCase().includes('tcp');
-        const mentionsUDP = response.toLowerCase().includes('udp');
-        console.log('\n--- Steering Checks ---');
-        console.log(`  Identifies as specialist: ${mentionsSpecialist ? 'YES' : 'NO'}`);
-        console.log(`  Has bullet points: ${hasBulletPoints ? 'YES' : 'NO'}`);
-        console.log(`  Covers TCP: ${mentionsTCP ? 'YES' : 'NO'}`);
-        console.log(`  Covers UDP: ${mentionsUDP ? 'YES' : 'NO'}`);
-    }
-    /**
-     * Test 2: Handoff with very specific formatting instructions
-     * Tests whether the receiving agent follows precise instructions from the handoff.
-     */
-    async function test2_preciseFormatting() {
-        console.log('\n' + '-'.repeat(60));
-        console.log('TEST 2: Handoff with precise formatting instructions');
-        console.log('-'.repeat(60));
-        const agents = [
-            {
-                agentId: 'manager',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are a Project Manager. When a user asks about a topic:
-1. Transfer to the writer with VERY SPECIFIC formatting instructions
-2. Tell the writer to start their response with "REPORT:" and end with "END REPORT"
-3. Tell the writer to use exactly 2 paragraphs
-
-CRITICAL: Always transfer to the writer. Do NOT write the report yourself.`,
-                maxContextTokens: 8000,
-            },
-            {
-                agentId: 'writer',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are a Report Writer. Follow any formatting instructions you receive precisely.
-You must follow the exact format requested.`,
-                maxContextTokens: 8000,
-            },
-        ];
-        const edges = [
-            {
-                from: 'manager',
-                to: 'writer',
-                edgeType: 'transfer',
-                description: 'Transfer to writer for report creation',
-                prompt: 'Provide specific formatting and content instructions for the writer',
-                promptKey: 'instructions',
-            },
-        ];
-        const run = await Run.create({
-            runId: `steering-test2-${Date.now()}`,
-            graphConfig: { type: 'multi-agent', agents, edges },
-            customHandlers,
-            returnContent: true,
-            skipCleanup: true,
-        });
-        const streamConfig = {
-            configurable: { thread_id: 'steering-test2' },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        const query = 'Write a brief report about cloud computing benefits.';
-        console.log(`\nQuery: "${query}"\n`);
-        const messages = [new HumanMessage(query)];
-        await run.processStream({ messages }, streamConfig);
-        const finalMessages = run.getRunMessages();
-        console.log('\n--- Writer Response ---');
-        if (finalMessages) {
-            for (const msg of finalMessages) {
-                if (msg.getType() === 'ai' && typeof msg.content === 'string') {
-                    console.log(msg.content);
-                    agentResponses['test2'] = msg.content;
-                }
-            }
-        }
-        // Check if the writer followed the manager's formatting instructions
-        const response = agentResponses['test2'] || '';
-        const startsWithReport = response.trimStart().startsWith('REPORT:');
-        const endsWithEndReport = response.trimEnd().endsWith('END REPORT');
-        const mentionsCloud = response.toLowerCase().includes('cloud');
-        console.log('\n--- Steering Checks ---');
-        console.log(`  Starts with "REPORT:": ${startsWithReport ? 'YES' : 'NO'}`);
-        console.log(`  Ends with "END REPORT": ${endsWithEndReport ? 'YES' : 'NO'}`);
-        console.log(`  Covers cloud computing: ${mentionsCloud ? 'YES' : 'NO'}`);
-    }
-    /**
-     * Test 3: Multi-turn after handoff
-     * Tests that identity and context persist across turns.
-     */
-    async function test3_multiTurn() {
-        console.log('\n' + '-'.repeat(60));
-        console.log('TEST 3: Multi-turn conversation after handoff');
-        console.log('-'.repeat(60));
-        const agents = [
-            {
-                agentId: 'router',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are a Router. Transfer all requests to the chef.
-When transferring, tell the chef to respond ONLY about Italian cuisine.
-CRITICAL: Always transfer. Never answer directly.`,
-                maxContextTokens: 8000,
-            },
-            {
-                agentId: 'chef',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_API_KEY,
-                },
-                instructions: `You are Chef Marco, an Italian cuisine expert.
-Always introduce yourself as Chef Marco. Only discuss Italian food.
-If asked about non-Italian food, politely redirect to Italian alternatives.`,
-                maxContextTokens: 8000,
-            },
-        ];
-        const edges = [
-            {
-                from: 'router',
-                to: 'chef',
-                edgeType: 'transfer',
-                description: 'Transfer to chef',
-                prompt: 'Instructions for the chef about how to respond',
-                promptKey: 'instructions',
-            },
-        ];
-        const run = await Run.create({
-            runId: `steering-test3-${Date.now()}`,
-            graphConfig: { type: 'multi-agent', agents, edges },
-            customHandlers,
-            returnContent: true,
-            skipCleanup: true,
-        });
-        const streamConfig = {
-            configurable: { thread_id: 'steering-test3' },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        const conversationHistory = [];
-        // Turn 1
-        const query1 = 'What is a good pasta recipe?';
-        console.log(`\nTurn 1: "${query1}"\n`);
-        conversationHistory.push(new HumanMessage(query1));
-        await run.processStream({ messages: conversationHistory }, streamConfig);
-        const turn1Messages = run.getRunMessages();
-        if (turn1Messages) {
-            conversationHistory.push(...turn1Messages);
-            for (const msg of turn1Messages) {
-                if (msg.getType() === 'ai' && typeof msg.content === 'string') {
-                    console.log(msg.content.substring(0, 300) + '...');
-                    agentResponses['test3_turn1'] = msg.content;
-                }
-            }
-        }
-        // Turn 2 - follow up
-        const query2 = 'What about sushi instead?';
-        console.log(`\nTurn 2: "${query2}"\n`);
-        conversationHistory.push(new HumanMessage(query2));
-        await run.processStream({ messages: conversationHistory }, streamConfig);
-        const turn2Messages = run.getRunMessages();
-        if (turn2Messages) {
-            conversationHistory.push(...turn2Messages);
-            for (const msg of turn2Messages) {
-                if (msg.getType() === 'ai' && typeof msg.content === 'string') {
-                    console.log(msg.content.substring(0, 300) + '...');
-                    agentResponses['test3_turn2'] = msg.content;
-                }
-            }
-        }
-        const response1 = agentResponses['test3_turn1'] || '';
-        const response2 = agentResponses['test3_turn2'] || '';
-        const t1Identity = response1.toLowerCase().includes('marco') ||
-            response1.toLowerCase().includes('chef');
-        const t1Italian = response1.toLowerCase().includes('italian') ||
-            response1.toLowerCase().includes('pasta');
-        const t2Redirects = response2.toLowerCase().includes('italian') ||
-            response2.toLowerCase().includes('instead');
-        console.log('\n--- Steering Checks ---');
-        console.log(`  Turn 1 - Chef identity: ${t1Identity ? 'YES' : 'NO'}`);
-        console.log(`  Turn 1 - Italian focus: ${t1Italian ? 'YES' : 'NO'}`);
-        console.log(`  Turn 2 - Redirects to Italian: ${t2Redirects ? 'YES' : 'NO'}`);
-    }
-    try {
-        await test1_basicInstructions();
-        await test2_preciseFormatting();
-        await test3_multiTurn();
-        console.log('\n\n' + '='.repeat(60));
-        console.log('ALL TESTS COMPLETE');
-        console.log('='.repeat(60));
-        console.log('\nReview the steering checks above.');
-        console.log('If the receiving agents consistently follow instructions and maintain identity,');
-        console.log('the system prompt injection approach is working correctly.');
-    }
-    catch (error) {
-        console.error('\nTest failed:', error);
-        process.exit(1);
-    }
-}
-process.on('unhandledRejection', (reason) => {
-    console.error('Unhandled Rejection:', reason);
-    process.exit(1);
-});
-testHandoffSteering().catch((err) => {
-    console.error('Test failed:', err);
-    process.exit(1);
-});
-//# sourceMappingURL=test-handoff-steering.js.map

package/src/scripts/test-multi-agent-list-handoff.js

@@ -1,318 +0,0 @@
-#!/usr/bin/env bun
-import { config } from 'dotenv';
-config();
-import { HumanMessage } from '@langchain/core/messages';
-import { labelContentByAgent, formatAgentMessages } from '@/messages/format';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { Providers, GraphEvents, Constants, StepTypes } from '@/common';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { Run } from '@/run';
-const conversationHistory = [];
-/**
- * Test supervisor-based multi-agent system using a single edge with multiple destinations
- *
- * Instead of creating 5 separate edges, we use one edge with an array of destinations
- * This should create handoff tools for all 5 specialists from a single edge definition
- */
-async function testSupervisorListHandoff() {
-    console.log('Testing Supervisor with List-Based Handoff Edge...\n');
-    // Set up content aggregator
-    const { contentParts, aggregateContent } = createContentAggregator();
-    // Track which specialist role was selected
-    let selectedRole = '';
-    // Create custom handlers
-    const customHandlers = {
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data) => {
-                const runStepData = data;
-                if (runStepData?.name) {
-                    console.log(`\n[${runStepData.name}] Processing...`);
-                }
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-            handle: (event, data) => {
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.TOOL_START]: {
-            handle: (_event, data, metadata) => {
-                const toolData = data;
-                if (toolData?.name?.startsWith(Constants.LC_TRANSFER_TO_)) {
-                    const specialist = toolData.name.replace(Constants.LC_TRANSFER_TO_, '');
-                    console.log(`\n🔀 Transferring to ${specialist}...`);
-                    selectedRole = specialist;
-                }
-            },
-        },
-    };
-    // Function to create the graph with a single edge to multiple specialists
-    function createSupervisorGraphWithListEdge() {
-        console.log(`\nCreating graph with supervisor and 5 specialist agents.`);
-        console.log('Using a SINGLE edge with multiple destinations (list-based handoff).\n');
-        // Define the adaptive specialist configuration that will be reused
-        const specialistConfig = {
-            provider: Providers.ANTHROPIC,
-            clientOptions: {
-                modelName: 'claude-haiku-4-5',
-                apiKey: process.env.ANTHROPIC_API_KEY,
-            },
-            instructions: `You are an Adaptive Specialist. Your agent ID indicates your role:
-      
-      - data_analyst: Focus on statistical analysis, metrics, ML evaluation, A/B testing
-      - security_expert: Focus on cybersecurity, vulnerability assessment, compliance  
-      - product_designer: Focus on UX/UI design, user research, accessibility
-      - devops_engineer: Focus on CI/CD, infrastructure, cloud platforms, monitoring
-      - legal_advisor: Focus on licensing, privacy laws, contracts, regulatory compliance
-      
-      The supervisor will provide specific instructions. Follow them while maintaining your expert perspective.`,
-            maxContextTokens: 8000,
-        };
-        // Create the graph with supervisor and all 5 specialists
-        const agents = [
-            {
-                agentId: 'supervisor',
-                provider: Providers.ANTHROPIC,
-                clientOptions: {
-                    modelName: 'claude-haiku-4-5',
-                    apiKey: process.env.ANTHROPIC_API_KEY,
-                },
-                instructions: `You are a Task Supervisor with access to 5 specialist agents:
-        1. transfer_to_data_analyst - For statistical analysis and metrics
-        2. transfer_to_security_expert - For cybersecurity and vulnerability assessment  
-        3. transfer_to_product_designer - For UX/UI design
-        4. transfer_to_devops_engineer - For infrastructure and deployment
-        5. transfer_to_legal_advisor - For compliance and licensing
-        
-        Your role is to:
-        1. Analyze the incoming request
-        2. Decide which specialist is best suited
-        3. Use the appropriate transfer tool (e.g., transfer_to_data_analyst)
-        4. Provide specific instructions to guide their work
-        
-        Be specific about what you need from the specialist.`,
-                maxContextTokens: 8000,
-            },
-            // Include all 5 specialists with the same adaptive configuration
-            {
-                agentId: 'data_analyst',
-                ...specialistConfig,
-            },
-            {
-                agentId: 'security_expert',
-                ...specialistConfig,
-            },
-            {
-                agentId: 'product_designer',
-                ...specialistConfig,
-            },
-            {
-                agentId: 'devops_engineer',
-                ...specialistConfig,
-            },
-            {
-                agentId: 'legal_advisor',
-                ...specialistConfig,
-            },
-        ];
-        // Create a SINGLE edge from supervisor to ALL 5 specialists using a list
-        const edges = [
-            {
-                from: 'supervisor',
-                to: [
-                    'data_analyst',
-                    'security_expert',
-                    'product_designer',
-                    'devops_engineer',
-                    'legal_advisor',
-                ],
-                description: 'Transfer to appropriate specialist based on task requirements',
-                edgeType: 'transfer',
-            },
-        ];
-        return {
-            runId: `supervisor-list-handoff-${Date.now()}`,
-            graphConfig: {
-                type: 'multi-agent',
-                agents,
-                edges,
-            },
-            customHandlers,
-            returnContent: true,
-            skipCleanup: true,
-        };
-    }
-    try {
-        // Test with different queries
-        const testQueries = [
-            'What are the legal implications of using GPL-licensed code in our product?',
-        ];
-        const config = {
-            configurable: {
-                thread_id: 'supervisor-list-handoff-1',
-            },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        for (const query of testQueries) {
-            console.log(`\n${'='.repeat(80)}`);
-            console.log(`FIRST RUN - USER QUERY: "${query}"`);
-            console.log('='.repeat(80));
-            // Reset conversation
-            conversationHistory.length = 0;
-            conversationHistory.push(new HumanMessage(query));
-            // Create graph with supervisor having a single edge to multiple specialists
-            const runConfig = createSupervisorGraphWithListEdge();
-            const run = await Run.create(runConfig);
-            console.log('Processing first request...');
-            // Process with streaming
-            const inputs = {
-                messages: conversationHistory,
-            };
-            const finalContentParts = await run.processStream(inputs, config);
-            const finalMessages = run.getRunMessages();
-            if (finalMessages) {
-                conversationHistory.push(...finalMessages);
-            }
-            // Demo: Map contentParts to agentIds
-            console.log(`\n${'─'.repeat(60)}`);
-            console.log('CONTENT PARTS TO AGENT MAPPING:');
-            console.log('─'.repeat(60));
-            if (run.Graph) {
-                // Get the mapping of contentPart index to agentId
-                const contentPartAgentMap = run.Graph.getContentPartAgentMap();
-                console.log(`\nTotal content parts: ${contentParts.length}`);
-                console.log(`\nContent Part → Agent Mapping:`);
-                contentPartAgentMap.forEach((agentId, index) => {
-                    const contentPart = contentParts[index];
-                    const contentType = contentPart?.type || 'unknown';
-                    const preview = contentType === 'text'
-                        ? contentPart.text?.slice(0, 50) || ''
-                        : contentType === 'tool_call'
-                            ? `Tool: ${contentPart.tool_call?.name || 'unknown'}`
-                            : contentType;
-                    console.log(`  [${index}] ${agentId} → ${contentType}: ${preview}${preview.length >= 50 ? '...' : ''}`);
-                });
-                // Show agent participation summary
-                console.log(`\n${'─'.repeat(60)}`);
-                console.log('AGENT PARTICIPATION SUMMARY:');
-                console.log('─'.repeat(60));
-                const activeAgents = run.Graph.getActiveAgentIds();
-                console.log(`\nActive agents (${activeAgents.length}):`, activeAgents);
-                const stepsByAgent = run.Graph.getRunStepsByAgent();
-                stepsByAgent.forEach((steps, agentId) => {
-                    const toolCallSteps = steps.filter((s) => s.type === StepTypes.TOOL_CALLS).length;
-                    const messageSteps = steps.filter((s) => s.type === StepTypes.MESSAGE_CREATION).length;
-                    console.log(`\n  ${agentId}:`);
-                    console.log(`    - Total steps: ${steps.length}`);
-                    console.log(`    - Message steps: ${messageSteps}`);
-                    console.log(`    - Tool call steps: ${toolCallSteps}`);
-                });
-            }
-            // Show graph structure summary
-            console.log(`\n${'─'.repeat(60)}`);
-            console.log(`GRAPH STRUCTURE:`);
-            console.log(`- Agents: 6 total (supervisor + 5 specialists)`);
-            console.log(`- Edges: 1 edge with multiple destinations`);
-            console.log(`- Edge type: handoff (creates individual tools for each destination)`);
-            console.log(`- Result: Supervisor has 5 handoff tools from a single edge`);
-            console.log('─'.repeat(60));
-            // =============================================================
-            // SECOND RUN: Demonstrate agent-labeled history
-            // =============================================================
-            console.log(`\n${'='.repeat(80)}`);
-            console.log(`SECOND RUN - Simulating DB Load with Agent-Labeled History`);
-            console.log('='.repeat(80));
-            // Simulate what happens in the main app:
-            // 1. Store contentParts + agentIdMap to "DB" (in-memory here)
-            const dbStoredContentParts = [...contentParts];
-            const dbStoredAgentIdMap = Object.fromEntries(run.Graph.getContentPartAgentMap());
-            console.log('\n📦 Simulating DB storage:');
-            console.log(`  - Stored ${dbStoredContentParts.length} content parts`);
-            console.log(`  - Stored agent mappings for ${Object.keys(dbStoredAgentIdMap).length} parts`);
-            // 2. On next run, load from "DB" and label by agent
-            console.log('\n📥 Loading from DB and labeling by agent...');
-            const agentNames = {
-                supervisor: 'Supervisor',
-                legal_advisor: 'Legal Advisor',
-                data_analyst: 'Data Analyst',
-                security_expert: 'Security Expert',
-                product_designer: 'Product Designer',
-                devops_engineer: 'DevOps Engineer',
-            };
-            const labeledContentParts = labelContentByAgent(dbStoredContentParts.filter((p) => p != null), dbStoredAgentIdMap, agentNames);
-            console.log(`  - Labeled ${labeledContentParts.length} content parts by agent`);
-            // 3. Convert labeled content parts to payload format
-            const payload = [
-                {
-                    role: 'user',
-                    content: query,
-                },
-                {
-                    role: 'assistant',
-                    content: labeledContentParts,
-                },
-            ];
-            // 4. Format using formatAgentMessages (simulates what main app does)
-            console.log('\n🔧 Calling formatAgentMessages...');
-            const { messages: formattedMessages } = formatAgentMessages(payload);
-            console.log(`  - Formatted into ${formattedMessages.length} BaseMessages`);
-            // Show a preview of what the supervisor will see
-            console.log('\n👁️  Preview of formatted history for supervisor:');
-            console.log('─'.repeat(80));
-            for (let i = 0; i < formattedMessages.length; i++) {
-                const msg = formattedMessages[i];
-                const role = msg._getType();
-                const preview = typeof msg.content === 'string'
-                    ? msg.content.slice(0, 200)
-                    : JSON.stringify(msg.content).slice(0, 200);
-                console.log(`[${i}] ${role}: ${preview}${preview.length >= 200 ? '...' : ''}`);
-            }
-            console.log('─'.repeat(80));
-            // 5. Create a new run with the formatted history + a followup question
-            console.log('\n🚀 Starting second run with agent-labeled history + followup question...');
-            const followupQuery = 'Can you summarize the key legal points from your previous response?';
-            console.log(`   Followup: "${followupQuery}"`);
-            // Reset for second run
-            const secondRunHistory = [
-                ...formattedMessages,
-                new HumanMessage(followupQuery),
-            ];
-            const runConfig2 = createSupervisorGraphWithListEdge();
-            const run2 = await Run.create(runConfig2);
-            const inputs2 = {
-                messages: secondRunHistory,
-            };
-            await run2.processStream(inputs2, config);
-            console.log('\n✅ Second run completed successfully!');
-            console.log('   The supervisor correctly understood that the legal_advisor handled');
-            console.log('   the previous query, avoiding identity confusion.');
-        }
-        // Final summary
-        console.log(`\n${'='.repeat(60)}`);
-        console.log('TEST COMPLETE');
-        console.log('='.repeat(60));
-        console.log('\nThis test demonstrates that a single edge with multiple');
-        console.log('destinations in the "to" field creates individual handoff');
-        console.log('tools for each destination agent, achieving the same result');
-        console.log('as creating separate edges for each specialist.');
-    }
-    catch (error) {
-        console.error('Error in supervisor list handoff test:', error);
-    }
-}
-// Run the test
-testSupervisorListHandoff();
-//# sourceMappingURL=test-multi-agent-list-handoff.js.map