@illuma-ai/agents 1.1.21 → 1.1.23

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

@@ -1,324 +0,0 @@
-import { config } from 'dotenv';
-config();
-import { HumanMessage } from '@langchain/core/messages';
-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 = [];
-/**
- * Example of supervisor-based multi-agent system
- *
- * The supervisor has handoff tools for 5 different specialists.
- * To demonstrate the concept while respecting LangGraph constraints,
- * we show two approaches:
- *
- * 1. All 5 specialists exist but share the same adaptive configuration
- * 2. Only 2 agents total by using a single adaptive specialist (requires workaround)
- */
-async function testSupervisorMultiAgent() {
-    console.log('Testing Supervisor-Based Multi-Agent System...\n');
-    // NOTE: To truly have only 2 agents with 5 handoff tools, you would need:
-    // 1. Custom tool implementation (see multi-agent-supervisor-mock.ts)
-    // 2. Or modify MultiAgentGraph to support "virtual" agents
-    // 3. Or use a single conditional edge with role parameter
-    //
-    // This example shows the concept using 6 agents that share configuration
-    // Set up content aggregator
-    const { contentParts, aggregateContent } = createContentAggregator();
-    // Define configurations for all possible specialists
-    const specialistConfigs = {
-        data_analyst: {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_API_KEY,
-            },
-            instructions: `You are a Data Analyst specialist. Your expertise includes:
-      - Statistical analysis and data visualization
-      - SQL queries and database optimization
-      - Python/R for data science
-      - Machine learning model evaluation
-      - A/B testing and experiment design
-      
-      Follow the supervisor's specific instructions carefully.`,
-            maxContextTokens: 8000,
-        },
-        security_expert: {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_API_KEY,
-            },
-            instructions: `You are a Security Expert. Your expertise includes:
-      - Cybersecurity best practices
-      - Vulnerability assessment and penetration testing
-      - Security architecture and threat modeling
-      - Compliance (GDPR, HIPAA, SOC2, etc.)
-      - Incident response and forensics
-      
-      Follow the supervisor's specific instructions carefully.`,
-            maxContextTokens: 8000,
-        },
-        product_designer: {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_API_KEY,
-            },
-            instructions: `You are a Product Designer. Your expertise includes:
-      - User experience (UX) design principles
-      - User interface (UI) design and prototyping
-      - Design systems and component libraries
-      - User research and usability testing
-      - Accessibility and inclusive design
-      
-      Follow the supervisor's specific instructions carefully.`,
-            maxContextTokens: 8000,
-        },
-        devops_engineer: {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_API_KEY,
-            },
-            instructions: `You are a DevOps Engineer. Your expertise includes:
-      - CI/CD pipeline design and optimization
-      - Infrastructure as Code (Terraform, CloudFormation)
-      - Container orchestration (Kubernetes, Docker)
-      - Cloud platforms (AWS, GCP, Azure)
-      - Monitoring, logging, and observability
-      
-      Follow the supervisor's specific instructions carefully.`,
-            maxContextTokens: 8000,
-        },
-        legal_advisor: {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_API_KEY,
-            },
-            instructions: `You are a Legal Advisor specializing in technology. Your expertise includes:
-      - Software licensing and open source compliance
-      - Data privacy and protection laws
-      - Intellectual property and patents
-      - Contract review and negotiation
-      - Regulatory compliance for tech companies
-      
-      Follow the supervisor's specific instructions carefully.`,
-            maxContextTokens: 8000,
-        },
-    };
-    // Track which specialist role was selected
-    let selectedRole = '';
-    let roleInstructions = '';
-    // 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) => {
-                console.dir(data, { depth: null });
-                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('transfer_to_', '');
-                    console.log(`\n🔀 Transferring to ${specialist}...`);
-                    selectedRole = specialist;
-                }
-            },
-        },
-    };
-    // Function to create the graph with supervisor having multiple handoff options
-    function createSupervisorGraph() {
-        console.log(`\nCreating graph with supervisor and 5 specialist agents.`);
-        console.log('All specialists share the same adaptive configuration.\n');
-        // Define the adaptive specialist configuration that will be reused
-        const specialistConfig = {
-            provider: Providers.OPENAI,
-            clientOptions: {
-                modelName: 'gpt-4.1',
-                apiKey: process.env.OPENAI_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
-        // All specialists share the same adaptive configuration
-        const agents = [
-            {
-                agentId: 'supervisor',
-                provider: Providers.OPENAI,
-                clientOptions: {
-                    modelName: 'gpt-4.1-mini',
-                    apiKey: process.env.OPENAI_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 edges from supervisor to all 5 specialists
-        const edges = [
-            {
-                from: 'supervisor',
-                to: 'data_analyst',
-                description: 'Transfer to data analyst for statistical analysis and metrics',
-                edgeType: 'transfer',
-            },
-            {
-                from: 'supervisor',
-                to: 'security_expert',
-                description: 'Transfer to security expert for cybersecurity assessment',
-                edgeType: 'transfer',
-            },
-            {
-                from: 'supervisor',
-                to: 'product_designer',
-                description: 'Transfer to product designer for UX/UI design',
-                edgeType: 'transfer',
-            },
-            {
-                from: 'supervisor',
-                to: 'devops_engineer',
-                description: 'Transfer to DevOps engineer for infrastructure and deployment',
-                edgeType: 'transfer',
-            },
-            {
-                from: 'supervisor',
-                to: 'legal_advisor',
-                description: 'Transfer to legal advisor for compliance and licensing',
-                edgeType: 'transfer',
-            },
-        ];
-        return {
-            runId: `supervisor-multi-agent-${Date.now()}`,
-            graphConfig: {
-                type: 'multi-agent',
-                agents,
-                edges,
-            },
-            customHandlers,
-            returnContent: true,
-            skipCleanup: true,
-        };
-    }
-    try {
-        // Test with different queries
-        const testQueries = [
-            'How can we analyze user engagement metrics to improve our product?',
-            // 'What security measures should we implement for our new API?',
-            // 'Can you help design a better onboarding flow for our mobile app?',
-            // 'We need to set up a CI/CD pipeline for our microservices.',
-            // 'What are the legal implications of using GPL-licensed code in our product?',
-        ];
-        const config = {
-            configurable: {
-                thread_id: 'supervisor-conversation-1',
-            },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        for (const query of testQueries) {
-            console.log(`\n${'='.repeat(60)}`);
-            console.log(`USER QUERY: "${query}"`);
-            console.log('='.repeat(60));
-            // Reset conversation
-            conversationHistory.length = 0;
-            conversationHistory.push(new HumanMessage(query));
-            // Create graph with supervisor having 5 handoff tools to 1 adaptive specialist
-            const runConfig = createSupervisorGraph();
-            const run = await Run.create(runConfig);
-            console.log('Processing request...');
-            // Process with streaming
-            const inputs = {
-                messages: conversationHistory,
-            };
-            const finalContentParts = await run.processStream(inputs, config);
-            const finalMessages = run.getRunMessages();
-            if (finalMessages) {
-                conversationHistory.push(...finalMessages);
-            }
-            // Show summary
-            console.log(`\n${'─'.repeat(60)}`);
-            console.log(`Agents in graph: 6 total (supervisor + 5 specialists)`);
-            console.log(`All specialists share the same adaptive configuration`);
-            console.log(`Supervisor tools: transfer_to_data_analyst, transfer_to_security_expert,`);
-            console.log(`                 transfer_to_product_designer, transfer_to_devops_engineer,`);
-            console.log(`                 transfer_to_legal_advisor`);
-            console.log('─'.repeat(60));
-            console.dir(contentParts, { depth: null });
-        }
-        await sleep(3000);
-    }
-    catch (error) {
-        console.error('Error in supervisor multi-agent test:', error);
-    }
-}
-// Run the test
-testSupervisorMultiAgent();
-//# sourceMappingURL=multi-agent-supervisor.js.map

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

@@ -1,147 +0,0 @@
-import { config } from 'dotenv';
-config();
-import { HumanMessage } from '@langchain/core/messages';
-import { Run } from '@/run';
-import { Providers, GraphEvents } from '@/common';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-const conversationHistory = [];
-async function testMultiAgentHandoff() {
-    console.log('Testing Multi-Agent Handoff System...\n');
-    // Set up content aggregator
-    const { contentParts, aggregateContent } = createContentAggregator();
-    // Define agent configurations
-    const agents = [
-        {
-            agentId: 'flight_assistant',
-            provider: Providers.ANTHROPIC,
-            clientOptions: {
-                modelName: 'claude-haiku-4-5',
-                apiKey: process.env.ANTHROPIC_API_KEY,
-            },
-            instructions: 'You are a flight booking assistant. Help users book flights between airports.',
-            maxContextTokens: 28000,
-        },
-        {
-            agentId: 'hotel_assistant',
-            provider: Providers.ANTHROPIC,
-            clientOptions: {
-                modelName: 'claude-haiku-4-5',
-                apiKey: process.env.ANTHROPIC_API_KEY,
-            },
-            instructions: 'You are a hotel booking assistant. Help users book hotel stays.',
-            maxContextTokens: 28000,
-        },
-    ];
-    // Define edges (handoff relationships)
-    // These edges create handoff tools that agents can use to transfer control dynamically
-    const edges = [
-        {
-            from: 'flight_assistant',
-            to: 'hotel_assistant',
-            description: 'Transfer to hotel booking assistant when user needs hotel assistance',
-            // edgeType defaults to 'handoff' for single-to-single edges
-        },
-        {
-            from: 'hotel_assistant',
-            to: 'flight_assistant',
-            description: 'Transfer to flight booking assistant when user needs flight assistance',
-            // edgeType defaults to 'handoff' for single-to-single edges
-        },
-    ];
-    // Create custom handlers similar to examples
-    const customHandlers = {
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                console.log('====== ON_RUN_STEP_COMPLETED ======');
-                console.dir(data, { depth: null });
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data) => {
-                console.log('====== ON_RUN_STEP ======');
-                console.dir(data, { depth: null });
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_DELTA]: {
-            handle: (event, data) => {
-                console.log('====== ON_RUN_STEP_DELTA ======');
-                console.dir(data, { depth: null });
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-            handle: (event, data) => {
-                console.log('====== ON_MESSAGE_DELTA ======');
-                console.dir(data, { depth: null });
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_REASONING_DELTA]: {
-            handle: (event, data) => {
-                console.log('====== ON_REASONING_DELTA ======');
-                console.dir(data, { depth: null });
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.TOOL_START]: {
-            handle: (_event, data, metadata) => {
-                console.log('====== TOOL_START ======');
-                console.dir(data, { depth: null });
-            },
-        },
-    };
-    // Create multi-agent run configuration
-    const runConfig = {
-        runId: `multi-agent-test-${Date.now()}`,
-        graphConfig: {
-            type: 'multi-agent',
-            agents,
-            edges,
-        },
-        customHandlers,
-        returnContent: true,
-        skipCleanup: true,
-    };
-    try {
-        // Create and execute the run
-        const run = await Run.create(runConfig);
-        const userMessage = 'I need to book a flight from Boston to New York, and also need a hotel near Times Square.';
-        conversationHistory.push(new HumanMessage(userMessage));
-        console.log('Invoking multi-agent graph...\n');
-        const config = {
-            configurable: {
-                thread_id: 'multi-agent-conversation-1',
-            },
-            streamMode: 'values',
-            version: 'v2',
-        };
-        // 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\nConversation history:');
-            console.dir(conversationHistory, { depth: null });
-        }
-        console.log('\n\nFinal content parts:');
-        console.dir(contentParts, { depth: null });
-    }
-    catch (error) {
-        console.error('Error in multi-agent test:', error);
-    }
-}
-// Run the test
-testMultiAgentHandoff();
-//# sourceMappingURL=multi-agent-test.js.map

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

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