@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/core/src/env/workflow/complex-workflow.integration.test.js

@@ -1,1588 +0,0 @@
-/**
- * Complex Multi-Node Workflow Integration Tests
- *
- * Tests for complex workflow patterns including:
- * - Parallel execution branches
- * - Diamond patterns (merge and fork)
- * - Error handling and retry logic
- * - Conditional execution
- * - Template variable passing
- * - Nested workflows
- * - Complex dependency graphs
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { z } from 'zod';
-/**
- * Synchronous Workflow Executor for Testing
- */
-class SyncWorkflowExecutor {
-    trace;
-    nodeConfigs;
-    constructor() {
-        this.trace = {
-            nodes: new Map(),
-            executionOrder: [],
-            parallelBatches: [],
-            errors: [],
-        };
-        this.nodeConfigs = new Map();
-    }
-    setNodeConfig(nodeId, config) {
-        this.nodeConfigs.set(nodeId, config);
-    }
-    getTrace() {
-        return this.trace;
-    }
-    clearTrace() {
-        this.trace = {
-            nodes: new Map(),
-            executionOrder: [],
-            parallelBatches: [],
-            errors: [],
-        };
-    }
-    executeNode(nodeId, input, dependencies, nodeType) {
-        const config = this.nodeConfigs.get(nodeId) || {};
-        // Initialize trace entry
-        const traceEntry = {
-            nodeId,
-            status: 'pending',
-            input,
-            output: null,
-            retryCount: 0,
-        };
-        this.trace.nodes.set(nodeId, traceEntry);
-        // Execute node
-        traceEntry.status = 'running';
-        traceEntry.startTime = Date.now();
-        // Use provided nodeType or fall back to config.type
-        const effectiveNodeType = nodeType || config.type || 'unknown';
-        let output;
-        switch (effectiveNodeType) {
-            case 'tool':
-                output = this.executeToolNode(nodeId, config, input);
-                break;
-            case 'skill':
-                output = this.executeSkillNode(nodeId, config, input, dependencies);
-                break;
-            case 'agent':
-                output = this.executeAgentNode(nodeId, config, input, dependencies);
-                break;
-            case 'condition':
-                output = this.executeConditionNode(nodeId, config, input);
-                break;
-            case 'merge':
-                output = this.executeMergeNode(nodeId, config, dependencies);
-                break;
-            case 'nested':
-            case 'workflow':
-                output = this.executeNestedWorkflowNode(nodeId, config, input);
-                break;
-            default:
-                output = { result: `${nodeId}_result`, input };
-        }
-        traceEntry.output = output;
-        traceEntry.status = 'completed';
-        traceEntry.endTime = Date.now();
-        this.trace.executionOrder.push(nodeId);
-        return output;
-    }
-    executeToolNode(nodeId, config, input) {
-        const toolName = config.tool || 'default-tool';
-        if (toolName === 'echo') {
-            return { echo: input, message: config.message };
-        }
-        if (toolName === 'calculator') {
-            return { result: 42, operation: config.operation };
-        }
-        if (toolName === 'validator') {
-            return { valid: true, validated: input, source: config.source };
-        }
-        return { tool: toolName, result: `processed_by_${toolName}` };
-    }
-    executeSkillNode(nodeId, config, input, dependencies) {
-        const skillName = config.skill || 'default-skill';
-        return {
-            skill: skillName,
-            result: `skill_${skillName}_executed`,
-            inputsFromDeps: Object.fromEntries(dependencies),
-        };
-    }
-    executeAgentNode(nodeId, config, input, dependencies) {
-        const agentType = config.agent || 'general';
-        return {
-            agent: agentType,
-            reasoning: `Agent ${agentType} processed input`,
-            input,
-        };
-    }
-    executeConditionNode(nodeId, config, input) {
-        const condition = config.condition || 'true';
-        const result = this.evaluateCondition(condition, input);
-        return { conditionMet: result, evaluatedCondition: condition };
-    }
-    executeMergeNode(nodeId, config, dependencies) {
-        const mergedInputs = {};
-        for (const [depId, depOutput] of dependencies) {
-            mergedInputs[depId] = depOutput;
-        }
-        return {
-            merged: true,
-            inputs: mergedInputs,
-            mergeStrategy: config.strategy || 'collect',
-            valid: true,
-        };
-    }
-    executeNestedWorkflowNode(nodeId, config, input) {
-        const workflowName = config.workflow || config.workflow_name || 'default-nested';
-        return {
-            nestedWorkflow: workflowName,
-            workflowName,
-            input,
-            result: `nested_${workflowName}_executed`,
-        };
-    }
-    evaluateCondition(condition, context) {
-        // Handle template variable conditions
-        if (condition === '{{input.skip}}') {
-            return context?.skip !== false && !!context?.skip;
-        }
-        if (condition === '{{input.mode}}') {
-            return !!context?.mode;
-        }
-        if (condition === 'true')
-            return true;
-        if (condition.includes('valid'))
-            return true;
-        if (condition.includes('{{process.result}}'))
-            return true;
-        return condition !== 'false';
-    }
-}
-// ==================== Workflow Execution Engine ====================
-function executeWorkflowSync(definition, input, executor) {
-    const exec = executor || new SyncWorkflowExecutor();
-    const results = new Map();
-    const nodeMap = new Map();
-    // Build node map and config
-    for (const node of definition.nodes) {
-        nodeMap.set(node.id, node);
-        exec.setNodeConfig(node.id, node.config);
-    }
-    // Topological sort for execution order
-    const order = topologicalSort(definition);
-    // Execute in order
-    const dependencies = new Map();
-    for (const nodeId of order) {
-        const node = nodeMap.get(nodeId);
-        // Get dependency outputs
-        const depOutputs = new Map();
-        for (const depId of node.depends_on || []) {
-            depOutputs.set(depId, dependencies.get(depId));
-        }
-        // Execute node with explicit node type
-        const output = exec.executeNode(nodeId, { ...input }, depOutputs, node.type);
-        dependencies.set(nodeId, output);
-        results.set(nodeId, output);
-    }
-    return results;
-}
-function topologicalSort(workflow) {
-    const nodeMap = new Map(workflow.nodes.map(n => [n.id, n]));
-    const visited = new Set();
-    const temp = new Set();
-    const order = [];
-    function visit(nodeId) {
-        if (temp.has(nodeId)) {
-            throw new Error(`Circular dependency detected: ${nodeId}`);
-        }
-        if (visited.has(nodeId))
-            return;
-        temp.add(nodeId);
-        const node = nodeMap.get(nodeId);
-        if (node) {
-            for (const depId of node.depends_on || []) {
-                visit(depId);
-            }
-        }
-        temp.delete(nodeId);
-        visited.add(nodeId);
-        order.push(nodeId);
-    }
-    // Visit all nodes
-    for (const node of workflow.nodes) {
-        if (!visited.has(node.id)) {
-            visit(node.id);
-        }
-    }
-    return order;
-}
-// ==================== Complex Workflow Definitions ====================
-/**
- * Complex Workflow: Data Processing Pipeline
- *
- * This workflow simulates a complex data processing pipeline with:
- * - 12 nodes total
- * - Parallel data fetching branches
- * - Diamond merge pattern
- * - Conditional processing
- * - Error handling with retry
- */
-const createDataProcessingWorkflow = () => ({
-    name: 'data-processing-pipeline',
-    version: '1.0',
-    description: 'Complex data processing pipeline with parallel branches',
-    config: {
-        parallel_limit: 3,
-        timeout: 300000,
-    },
-    nodes: [
-        // Entry node - Initialize pipeline
-        {
-            id: 'init',
-            type: 'tool',
-            name: 'Initialize Pipeline',
-            config: { tool: 'echo', message: 'Starting data pipeline' },
-        },
-        // Parallel fetch branch 1
-        {
-            id: 'fetch-users',
-            type: 'tool',
-            name: 'Fetch Users',
-            config: { tool: 'validator', source: 'users' },
-            depends_on: ['init'],
-        },
-        // Parallel fetch branch 2
-        {
-            id: 'fetch-products',
-            type: 'tool',
-            name: 'Fetch Products',
-            config: { tool: 'validator', source: 'products' },
-            depends_on: ['init'],
-        },
-        // Parallel fetch branch 3
-        {
-            id: 'fetch-orders',
-            type: 'tool',
-            name: 'Fetch Orders',
-            config: { tool: 'validator', source: 'orders' },
-            depends_on: ['init'],
-        },
-        // Diamond pattern - merge point
-        {
-            id: 'merge-data',
-            type: 'merge',
-            name: 'Merge All Data',
-            config: { strategy: 'collect' },
-            depends_on: ['fetch-users', 'fetch-products', 'fetch-orders'],
-        },
-        // Diamond pattern - fork to processing branches
-        {
-            id: 'validate-data',
-            type: 'condition',
-            name: 'Validate Merged Data',
-            config: { condition: '{{merge-data.valid}}' },
-            depends_on: ['merge-data'],
-        },
-        // Processing branch 1 - with retry
-        {
-            id: 'process-users',
-            type: 'tool',
-            name: 'Process Users',
-            config: { tool: 'calculator', operation: 'user-scoring' },
-            depends_on: ['validate-data'],
-            retry: { max_attempts: 3, backoff: 'exponential', initial_delay: 1000 },
-        },
-        // Processing branch 2
-        {
-            id: 'process-products',
-            type: 'tool',
-            name: 'Process Products',
-            config: { tool: 'calculator', operation: 'product-rating' },
-            depends_on: ['validate-data'],
-        },
-        // Diamond merge - final processing
-        {
-            id: 'finalize-results',
-            type: 'tool',
-            name: 'Finalize Results',
-            config: { tool: 'echo', message: 'Finalizing' },
-            depends_on: ['process-users', 'process-products'],
-        },
-        // Conditional node
-        {
-            id: 'generate-report',
-            type: 'condition',
-            name: 'Check Report Generation',
-            config: { condition: '{{input.generateReport}}' },
-            depends_on: ['finalize-results'],
-        },
-        // Nested workflow call
-        {
-            id: 'create-report',
-            type: 'nested',
-            name: 'Create Report',
-            config: { workflow: 'report-generation' },
-            depends_on: ['generate-report'],
-        },
-        // Final output node
-        {
-            id: 'output',
-            type: 'tool',
-            name: 'Output Results',
-            config: { tool: 'echo', message: 'Pipeline complete' },
-            depends_on: ['create-report'],
-        },
-    ],
-    entry: 'init',
-    outputs: [
-        { name: 'final_result', source: 'output', path: 'result' },
-        { name: 'user_data', source: 'process-users', path: 'result' },
-        { name: 'product_data', source: 'process-products', path: 'result' },
-    ],
-    metadata: {
-        author: 'Roy Agent',
-        tags: ['data-processing', 'pipeline', 'complex'],
-    },
-});
-/**
- * Complex Workflow: Parallel Processing with Error Handling
- *
- * Features:
- * - Multiple parallel branches
- * - Retry logic on failure-prone nodes
- * - Error recovery paths
- * - Timeout handling
- */
-const createParallelProcessingWorkflow = () => ({
-    name: 'parallel-processing',
-    version: '1.0',
-    description: 'Parallel processing with error handling and retry',
-    nodes: [
-        { id: 'entry', type: 'tool', config: { tool: 'echo' } },
-        // Parallel branch A
-        { id: 'task-a1', type: 'tool', config: { tool: 'calculator' }, depends_on: ['entry'] },
-        { id: 'task-a2', type: 'tool', config: { tool: 'calculator' }, depends_on: ['task-a1'] },
-        { id: 'task-a3', type: 'tool', config: { tool: 'calculator' }, depends_on: ['task-a2'] },
-        // Parallel branch B
-        { id: 'task-b1', type: 'tool', config: { tool: 'calculator' }, depends_on: ['entry'] },
-        { id: 'task-b2', type: 'tool', config: { tool: 'calculator' }, depends_on: ['task-b1'] },
-        {
-            id: 'task-b3',
-            type: 'tool',
-            config: { tool: 'calculator' },
-            depends_on: ['task-b1'],
-            retry: { max_attempts: 2, backoff: 'fixed', initial_delay: 500 },
-        },
-        // Parallel branch C - with potential failure
-        { id: 'task-c1', type: 'tool', config: { tool: 'calculator' }, depends_on: ['entry'] },
-        {
-            id: 'task-c2',
-            type: 'tool',
-            config: { tool: 'calculator' },
-            depends_on: ['task-c1'],
-            retry: { max_attempts: 3, backoff: 'exponential', initial_delay: 1000 },
-        },
-        // Merge all branches
-        {
-            id: 'merge-ab',
-            type: 'merge',
-            config: { strategy: 'collect' },
-            depends_on: ['task-a3', 'task-b2', 'task-c2'],
-        },
-        // Final processing
-        { id: 'final', type: 'tool', config: { tool: 'echo' }, depends_on: ['merge-ab'] },
-    ],
-});
-/**
- * Complex Workflow: Nested Workflow Composition
- *
- * Features:
- * - Nested workflow calls
- * - Multiple levels of abstraction
- * - Shared state passing
- * - Complex dependency chains
- */
-const createNestedWorkflow = () => ({
-    name: 'nested-workflow-composition',
-    version: '1.0',
-    nodes: [
-        { id: 'start', type: 'tool', config: { tool: 'echo' }, depends_on: [] },
-        // First level nested
-        { id: 'sub-workflow-1', type: 'workflow', config: { workflow_name: 'sub-workflow-a' }, depends_on: ['start'] },
-        { id: 'sub-workflow-2', type: 'workflow', config: { workflow_name: 'sub-workflow-b' }, depends_on: ['start'] },
-        // Second level - parallel execution
-        { id: 'level-2-a', type: 'tool', config: { tool: 'validator' }, depends_on: ['sub-workflow-1'] },
-        { id: 'level-2-b', type: 'tool', config: { tool: 'validator' }, depends_on: ['sub-workflow-1'] },
-        { id: 'level-2-c', type: 'tool', config: { tool: 'validator' }, depends_on: ['sub-workflow-2'] },
-        // Merge and continue
-        { id: 'merge-2', type: 'merge', config: { strategy: 'collect' }, depends_on: ['level-2-a', 'level-2-b', 'level-2-c'] },
-        // Third level
-        { id: 'level-3', type: 'tool', config: { tool: 'calculator' }, depends_on: ['merge-2'] },
-        // Final nested call
-        { id: 'final-nested', type: 'workflow', config: { workflow_name: 'final-workflow' }, depends_on: ['level-3'] },
-    ],
-});
-/**
- * Complex Workflow: Conditional Execution Graph
- *
- * Features:
- * - Multiple conditional branches
- * - Skip logic
- * - Dynamic paths based on runtime conditions
- */
-const createConditionalWorkflow = () => ({
-    name: 'conditional-execution',
-    version: '1.0',
-    nodes: [
-        { id: 'init', type: 'tool', config: { tool: 'echo' } },
-        // First condition
-        {
-            id: 'check-mode',
-            type: 'condition',
-            config: { condition: '{{input.mode}}' },
-            depends_on: ['init'],
-        },
-        // Mode A path
-        { id: 'mode-a-1', type: 'tool', config: { tool: 'calculator' }, depends_on: ['check-mode'] },
-        { id: 'mode-a-2', type: 'tool', config: { tool: 'calculator' }, depends_on: ['mode-a-1'] },
-        // Mode B path
-        { id: 'mode-b-1', type: 'tool', config: { tool: 'validator' }, depends_on: ['check-mode'] },
-        { id: 'mode-b-2', type: 'tool', config: { tool: 'validator' }, depends_on: ['mode-b-1'] },
-        // Merge after conditional paths
-        { id: 'merge-cond', type: 'merge', config: { strategy: 'collect' }, depends_on: ['mode-a-2', 'mode-b-2'] },
-        // Final check
-        {
-            id: 'final-check',
-            type: 'condition',
-            config: { condition: '{{merge-cond.valid}}' },
-            depends_on: ['merge-cond'],
-        },
-        // Output
-        { id: 'output', type: 'tool', config: { tool: 'echo' }, depends_on: ['final-check'] },
-    ],
-});
-/**
- * Complex Workflow: Diamond Pattern
- *
- * A -> B1 -> C -> D
- *   -> B2 ->
- *   -> B3 ->
- *
- * Classic diamond dependency pattern
- */
-const createDiamondWorkflow = () => ({
-    name: 'diamond-pattern',
-    version: '1.0',
-    nodes: [
-        { id: 'A', type: 'tool', config: { tool: 'echo' }, depends_on: [] },
-        { id: 'B1', type: 'tool', config: { tool: 'calculator' }, depends_on: ['A'] },
-        { id: 'B2', type: 'tool', config: { tool: 'calculator' }, depends_on: ['A'] },
-        { id: 'B3', type: 'tool', config: { tool: 'calculator' }, depends_on: ['A'] },
-        {
-            id: 'C',
-            type: 'tool',
-            config: { tool: 'calculator' },
-            depends_on: ['B1', 'B2', 'B3'],
-            retry: { max_attempts: 2, backoff: 'exponential', initial_delay: 500 },
-        },
-        { id: 'D', type: 'tool', config: { tool: 'echo' }, depends_on: ['C'] },
-    ],
-});
-/**
- * Complex Workflow: Multi-Node Type Orchestration
- *
- * Demonstrates chaining different node types:
- * - ToolNode → AgentNode → SkillNode → WorkflowNode → ToolNode
- * - Template variable passing between different node types
- * - Real-world AI pipeline pattern
- */
-const createMultiNodeTypeWorkflow = () => ({
-    name: 'multi-node-type-orchestration',
-    version: '1.0',
-    description: 'Orchestration across Tool, Agent, Skill, and Workflow nodes',
-    nodes: [
-        // ========== Step 1: Tool - Data Preparation ==========
-        {
-            id: 'prepare-data',
-            type: 'tool',
-            name: 'Prepare Input Data',
-            config: { tool: 'echo', message: 'Preparing initial data' },
-            depends_on: [],
-        },
-        // ========== Step 2: Agent - Analysis ==========
-        {
-            id: 'analyze-data',
-            type: 'agent',
-            name: 'AI Data Analyst',
-            config: {
-                agent_type: 'general',
-                prompt: 'Analyze the input data: {{prepare-data.output}}. Provide insights.',
-            },
-            depends_on: ['prepare-data'],
-        },
-        // ========== Step 3: Tool - Validate Analysis ==========
-        {
-            id: 'validate-analysis',
-            type: 'tool',
-            name: 'Validate Analysis Results',
-            config: { tool: 'validator', source: 'analysis' },
-            depends_on: ['analyze-data'],
-        },
-        // ========== Step 4: Agent - Decision Making ==========
-        {
-            id: 'make-decision',
-            type: 'agent',
-            name: 'Decision Agent',
-            config: {
-                agent_type: 'general',
-                prompt: 'Based on analysis: {{analyze-data.output}}, decide next steps.',
-            },
-            depends_on: ['validate-analysis'],
-        },
-        // ========== Step 5: Skill - Transform Data ==========
-        {
-            id: 'transform-data',
-            type: 'skill',
-            name: 'Data Transformation Skill',
-            config: {
-                skill: 'data-transform',
-                input: {
-                    data: '{{analyze-data.output}}',
-                    format: 'json',
-                },
-            },
-            depends_on: ['make-decision'],
-        },
-        // ========== Step 6: Nested Workflow ==========
-        {
-            id: 'process-workflow',
-            type: 'workflow',
-            name: 'Sub-Process Workflow',
-            config: {
-                workflow_name: 'data-processing-subflow',
-                input: {
-                    source: '{{transform-data.output}}',
-                },
-            },
-            depends_on: ['transform-data'],
-        },
-        // ========== Step 7: Tool - Final Output ==========
-        {
-            id: 'format-output',
-            type: 'tool',
-            name: 'Format Final Output',
-            config: { tool: 'calculator', operation: 'format' },
-            depends_on: ['process-workflow'],
-        },
-    ],
-    outputs: [
-        { name: 'analysis_result', source: 'analyze-data', path: 'output' },
-        { name: 'decision', source: 'make-decision', path: 'output' },
-        { name: 'transformed_data', source: 'transform-data', path: 'output' },
-        { name: 'final_result', source: 'format-output', path: 'result' },
-    ],
-    metadata: {
-        author: 'Roy Agent',
-        tags: ['multi-node', 'orchestration', 'ai-pipeline'],
-    },
-});
-/**
- * Complex Workflow: Tool-Skill-Agent Chain
- *
- * A realistic AI pipeline demonstrating:
- * - Tool (data fetch)
- * - Agent (reasoning)
- * - Skill (processing)
- * - Another Agent (verification)
- * - Tool (output)
- */
-const createToolSkillAgentChain = () => ({
-    name: 'tool-skill-agent-chain',
-    version: '1.0',
-    nodes: [
-        // Tool: Fetch raw data
-        {
-            id: 'fetch-raw-data',
-            type: 'tool',
-            name: 'Fetch Raw Data',
-            config: { tool: 'echo', message: 'Fetching data from source' },
-            depends_on: [],
-        },
-        // Agent: Initial understanding
-        {
-            id: 'understand-context',
-            type: 'agent',
-            name: 'Context Understanding Agent',
-            config: {
-                agent_type: 'general',
-                prompt: 'Understand the context of: {{fetch-raw-data.output}}',
-            },
-            depends_on: ['fetch-raw-data'],
-        },
-        // Skill: Process with skill
-        {
-            id: 'process-with-skill',
-            type: 'skill',
-            name: 'Processing Skill',
-            config: {
-                skill: 'text-processor',
-                input: {
-                    text: '{{understand-context.output}}',
-                    options: { lowercase: true },
-                },
-            },
-            depends_on: ['understand-context'],
-        },
-        // Agent: Deep reasoning
-        {
-            id: 'deep-reasoning',
-            type: 'agent',
-            name: 'Deep Reasoning Agent',
-            config: {
-                agent_type: 'general',
-                prompt: 'Perform deep reasoning on: {{process-with-skill.output}}',
-            },
-            depends_on: ['process-with-skill'],
-        },
-        // Skill: Another skill processing
-        {
-            id: 'enhance-result',
-            type: 'skill',
-            name: 'Enhancement Skill',
-            config: {
-                skill: 'enhancer',
-                input: {
-                    data: '{{deep-reasoning.output}}',
-                },
-            },
-            depends_on: ['deep-reasoning'],
-        },
-        // Tool: Final validation
-        {
-            id: 'final-validate',
-            type: 'tool',
-            name: 'Final Validation',
-            config: { tool: 'validator', source: 'final' },
-            depends_on: ['enhance-result'],
-        },
-    ],
-});
-/**
- * Complex Workflow: Parallel Tool-Agent Branches
- *
- * Multiple parallel branches, each with Tool → Agent pattern
- */
-const createParallelToolAgentWorkflow = () => ({
-    name: 'parallel-tool-agent-branches',
-    version: '1.0',
-    nodes: [
-        // Entry
-        { id: 'start', type: 'tool', config: { tool: 'echo' }, depends_on: [] },
-        // Branch A: Tool → Agent
-        { id: 'tool-a', type: 'tool', config: { tool: 'calculator' }, depends_on: ['start'] },
-        {
-            id: 'agent-a',
-            type: 'agent',
-            config: { agent_type: 'general', prompt: 'Process: {{tool-a.output}}' },
-            depends_on: ['tool-a'],
-        },
-        // Branch B: Tool → Agent
-        { id: 'tool-b', type: 'tool', config: { tool: 'validator' }, depends_on: ['start'] },
-        {
-            id: 'agent-b',
-            type: 'agent',
-            config: { agent_type: 'general', prompt: 'Process: {{tool-b.output}}' },
-            depends_on: ['tool-b'],
-        },
-        // Branch C: Tool → Agent
-        { id: 'tool-c', type: 'tool', config: { tool: 'echo' }, depends_on: ['start'] },
-        {
-            id: 'agent-c',
-            type: 'agent',
-            config: { agent_type: 'general', prompt: 'Process: {{tool-c.output}}' },
-            depends_on: ['tool-c'],
-        },
-        // Merge all agent outputs
-        {
-            id: 'merge-agents',
-            type: 'merge',
-            config: { strategy: 'collect' },
-            depends_on: ['agent-a', 'agent-b', 'agent-c'],
-        },
-        // Final aggregation agent
-        {
-            id: 'aggregate-results',
-            type: 'agent',
-            name: 'Aggregation Agent',
-            config: {
-                agent_type: 'general',
-                prompt: 'Aggregate and summarize results from all branches.',
-            },
-            depends_on: ['merge-agents'],
-        },
-        // Output tool
-        { id: 'output', type: 'tool', config: { tool: 'echo' }, depends_on: ['aggregate-results'] },
-    ],
-});
-/**
- * Complex Workflow: Template Variable Passing
- *
- * Tests HIL (Human Input Language) template variable passing
- */
-const createTemplateVariableWorkflow = () => ({
-    name: 'template-variables',
-    version: '1.0',
-    nodes: [
-        {
-            id: 'init',
-            type: 'tool',
-            config: { tool: 'echo', message: '{{input.greeting}}' },
-        },
-        {
-            id: 'process',
-            type: 'tool',
-            config: { tool: 'calculator', expression: '{{init.result}} + {{input.value}}' },
-            depends_on: ['init'],
-        },
-        {
-            id: 'validate',
-            type: 'condition',
-            config: { condition: '{{process.result}} > {{input.threshold}}' },
-            depends_on: ['process'],
-        },
-        {
-            id: 'output',
-            type: 'tool',
-            config: { tool: 'echo', message: 'Result: {{process.result}}, Valid: {{validate.conditionMet}}' },
-            depends_on: ['validate'],
-        },
-    ],
-});
-/**
- * Complex Workflow: Complex Dependency Graph
- *
- * Features:
- * - Multiple entry points
- * - Complex merge patterns
- * - Cross-branch dependencies
- */
-const createComplexDependencyWorkflow = () => ({
-    name: 'complex-dependency-graph',
-    version: '1.0',
-    nodes: [
-        // Two entry points
-        { id: 'entry-1', type: 'tool', config: { tool: 'echo' }, depends_on: [] },
-        { id: 'entry-2', type: 'tool', config: { tool: 'echo' }, depends_on: [] },
-        // Parallel branches from entry-1
-        { id: 'branch-1a', type: 'tool', config: { tool: 'calculator' }, depends_on: ['entry-1'] },
-        { id: 'branch-1b', type: 'tool', config: { tool: 'calculator' }, depends_on: ['entry-1'] },
-        // Parallel branches from entry-2
-        { id: 'branch-2a', type: 'tool', config: { tool: 'validator' }, depends_on: ['entry-2'] },
-        { id: 'branch-2b', type: 'tool', config: { tool: 'validator' }, depends_on: ['entry-2'] },
-        // Cross-branch dependency: branch-1a depends on branch-2a
-        { id: 'cross-dep', type: 'tool', config: { tool: 'calculator' }, depends_on: ['branch-1a', 'branch-2a'] },
-        // Merge all
-        { id: 'merge-1', type: 'merge', config: { strategy: 'collect' }, depends_on: ['branch-1b', 'branch-2b', 'cross-dep'] },
-        // Final processing
-        { id: 'final', type: 'tool', config: { tool: 'echo' }, depends_on: ['merge-1'] },
-    ],
-});
-// ==================== Test Suites ====================
-describe('Complex Multi-Node Workflow Integration Tests', () => {
-    let executor;
-    beforeEach(() => {
-        executor = new SyncWorkflowExecutor();
-    });
-    afterEach(() => {
-        executor.clearTrace();
-    });
-    // ==================== Workflow Structure Tests ====================
-    describe('Data Processing Pipeline Workflow', () => {
-        const workflow = createDataProcessingWorkflow();
-        it('should have 12 nodes', () => {
-            expect(workflow.nodes).toHaveLength(12);
-        });
-        it('should have correct node IDs', () => {
-            const nodeIds = workflow.nodes.map(n => n.id);
-            expect(nodeIds).toContain('init');
-            expect(nodeIds).toContain('merge-data');
-            expect(nodeIds).toContain('finalize-results');
-            expect(nodeIds).toContain('output');
-        });
-        it('should have parallel branches from init', () => {
-            const fetchNodes = workflow.nodes.filter(n => n.depends_on && n.depends_on.includes('init'));
-            expect(fetchNodes.length).toBe(3); // fetch-users, fetch-products, fetch-orders
-        });
-        it('should have diamond pattern with merge-data', () => {
-            const mergeNode = workflow.nodes.find(n => n.id === 'merge-data');
-            expect(mergeNode.depends_on).toBeDefined();
-            expect(mergeNode.depends_on).toContain('fetch-users');
-            expect(mergeNode.depends_on).toContain('fetch-products');
-            expect(mergeNode.depends_on).toContain('fetch-orders');
-        });
-        it('should have nodes with retry configuration', () => {
-            const retryNode = workflow.nodes.find(n => n.id === 'process-users');
-            expect(retryNode.retry).toBeDefined();
-            expect(retryNode.retry?.max_attempts).toBe(3);
-            expect(retryNode.retry?.backoff).toBe('exponential');
-        });
-        it('should have nested workflow node', () => {
-            const nestedNode = workflow.nodes.find(n => n.id === 'create-report');
-            expect(nestedNode.type).toBe('nested');
-            expect(nestedNode.config.workflow).toBe('report-generation');
-        });
-        it('should have correct output definitions', () => {
-            expect(workflow.outputs).toHaveLength(3);
-            expect(workflow.outputs?.find(o => o.name === 'final_result')?.source).toBe('output');
-        });
-        it('should have metadata with tags', () => {
-            expect(workflow.metadata?.tags).toContain('data-processing');
-            expect(workflow.metadata?.author).toBe('Roy Agent');
-        });
-        it('should execute in correct topological order', () => {
-            const order = topologicalSort(workflow);
-            // init should come before fetch-*
-            expect(order.indexOf('init')).toBeLessThan(order.indexOf('fetch-users'));
-            expect(order.indexOf('init')).toBeLessThan(order.indexOf('fetch-products'));
-            expect(order.indexOf('init')).toBeLessThan(order.indexOf('fetch-orders'));
-            // merge-data should come after all fetches
-            expect(order.indexOf('merge-data')).toBeGreaterThan(order.indexOf('fetch-users'));
-            expect(order.indexOf('merge-data')).toBeGreaterThan(order.indexOf('fetch-products'));
-            expect(order.indexOf('merge-data')).toBeGreaterThan(order.indexOf('fetch-orders'));
-        });
-        it('should execute all nodes successfully', () => {
-            const results = executeWorkflowSync(workflow, { generateReport: true }, executor);
-            expect(results.size).toBe(12);
-            expect(results.has('init')).toBe(true);
-            expect(results.has('merge-data')).toBe(true);
-            expect(results.has('output')).toBe(true);
-            // Verify execution order in trace
-            const trace = executor.getTrace();
-            expect(trace.executionOrder.length).toBe(12);
-            expect(trace.executionOrder[0]).toBe('init');
-            expect(trace.executionOrder[11]).toBe('output');
-        });
-    });
-    describe('Parallel Processing Workflow', () => {
-        const workflow = createParallelProcessingWorkflow();
-        it('should have parallel branches from entry', () => {
-            const parallelNodes = workflow.nodes.filter(n => n.depends_on?.includes('entry'));
-            expect(parallelNodes.length).toBe(3); // task-a1, task-b1, task-c1
-        });
-        it('should have correct branch structures', () => {
-            // Branch A: entry -> a1 -> a2 -> a3
-            expect(workflow.nodes.find(n => n.id === 'task-a1')?.depends_on).toContain('entry');
-            expect(workflow.nodes.find(n => n.id === 'task-a2')?.depends_on).toContain('task-a1');
-            expect(workflow.nodes.find(n => n.id === 'task-a3')?.depends_on).toContain('task-a2');
-            // Branch B: entry -> b1 -> b2/b3
-            expect(workflow.nodes.find(n => n.id === 'task-b1')?.depends_on).toContain('entry');
-            expect(workflow.nodes.find(n => n.id === 'task-b2')?.depends_on).toContain('task-b1');
-            expect(workflow.nodes.find(n => n.id === 'task-b3')?.depends_on).toContain('task-b1');
-            // Branch C: entry -> c1 -> c2
-            expect(workflow.nodes.find(n => n.id === 'task-c1')?.depends_on).toContain('entry');
-            expect(workflow.nodes.find(n => n.id === 'task-c2')?.depends_on).toContain('task-c1');
-        });
-        it('should have retry configured on specific nodes', () => {
-            const retryNode = workflow.nodes.find(n => n.id === 'task-b3');
-            expect(retryNode.retry?.max_attempts).toBe(2);
-            expect(retryNode.retry?.backoff).toBe('fixed');
-            const retryNode2 = workflow.nodes.find(n => n.id === 'task-c2');
-            expect(retryNode2.retry?.max_attempts).toBe(3);
-            expect(retryNode2.retry?.backoff).toBe('exponential');
-        });
-        it('should merge at merge-ab node', () => {
-            const mergeNode = workflow.nodes.find(n => n.id === 'merge-ab');
-            expect(mergeNode.depends_on).toContain('task-a3');
-            expect(mergeNode.depends_on).toContain('task-b2');
-            expect(mergeNode.depends_on).toContain('task-c2');
-        });
-        it('should execute all nodes', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            // entry + 3 branches * 3 nodes each (minus b3 since b2 and b3 both depend on b1) + merge + final
-            // 1 + 3 + 3 + 3 + 1 + 1 = 12... wait, let me count again
-            // entry, task-a1, task-a2, task-a3, task-b1, task-b2, task-b3, task-c1, task-c2, merge-ab, final = 11 nodes
-            expect(results.size).toBe(11);
-        });
-    });
-    describe('Nested Workflow Composition', () => {
-        const workflow = createNestedWorkflow();
-        it('should have multiple workflow nodes', () => {
-            const workflowNodes = workflow.nodes.filter(n => n.type === 'workflow');
-            expect(workflowNodes.length).toBe(3);
-        });
-        it('should have hierarchical structure', () => {
-            const startNode = workflow.nodes.find(n => n.id === 'start');
-            expect(startNode.depends_on).toBeDefined();
-            expect(startNode.depends_on.length).toBe(0);
-            const subWorkflow1 = workflow.nodes.find(n => n.id === 'sub-workflow-1');
-            expect(subWorkflow1.depends_on).toBeDefined();
-            expect(subWorkflow1.depends_on).toContain('start');
-        });
-        it('should execute workflow nodes', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            expect(results.has('sub-workflow-1')).toBe(true);
-            expect(results.has('final-nested')).toBe(true);
-            const nestedResult = results.get('sub-workflow-1');
-            expect(nestedResult).toBeDefined();
-            expect(nestedResult.nestedWorkflow).toBe('sub-workflow-a');
-        });
-    });
-    describe('Multi-Node Type Orchestration', () => {
-        const workflow = createMultiNodeTypeWorkflow();
-        it('should have various node types', () => {
-            const toolNodes = workflow.nodes.filter(n => n.type === 'tool');
-            const agentNodes = workflow.nodes.filter(n => n.type === 'agent');
-            const skillNodes = workflow.nodes.filter(n => n.type === 'skill');
-            const workflowNodes = workflow.nodes.filter(n => n.type === 'workflow');
-            expect(toolNodes.length).toBeGreaterThan(0);
-            expect(agentNodes.length).toBeGreaterThan(0);
-            expect(skillNodes.length).toBeGreaterThan(0);
-            expect(workflowNodes.length).toBeGreaterThan(0);
-        });
-        it('should have correct dependency chain', () => {
-            const prepareData = workflow.nodes.find(n => n.id === 'prepare-data');
-            expect(prepareData.depends_on?.length).toBe(0);
-            const analyzeData = workflow.nodes.find(n => n.id === 'analyze-data');
-            expect(analyzeData.depends_on).toContain('prepare-data');
-            const makeDecision = workflow.nodes.find(n => n.id === 'make-decision');
-            expect(makeDecision.depends_on).toContain('validate-analysis');
-        });
-        it('should have agent nodes with prompts', () => {
-            const agentNodes = workflow.nodes.filter(n => n.type === 'agent');
-            for (const agentNode of agentNodes) {
-                expect(agentNode.config).toBeDefined();
-                expect(agentNode.config.prompt).toBeDefined();
-            }
-        });
-        it('should have skill nodes with skill names', () => {
-            const skillNodes = workflow.nodes.filter(n => n.type === 'skill');
-            for (const skillNode of skillNodes) {
-                expect(skillNode.config).toBeDefined();
-                expect(skillNode.config.skill).toBeDefined();
-            }
-        });
-        it('should execute all node types', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            // All 7 nodes should be executed
-            // prepare-data, analyze-data, validate-analysis, make-decision, transform-data, process-workflow, format-output
-            expect(results.size).toBe(7);
-            // Verify tool nodes executed
-            expect(results.has('prepare-data')).toBe(true);
-            expect(results.has('format-output')).toBe(true);
-            // Verify agent nodes executed
-            expect(results.has('analyze-data')).toBe(true);
-            expect(results.has('make-decision')).toBe(true);
-            // Verify skill nodes executed
-            expect(results.has('transform-data')).toBe(true);
-            // Verify workflow nodes executed
-            expect(results.has('process-workflow')).toBe(true);
-        });
-    });
-    describe('Tool-Skill-Agent Chain', () => {
-        const workflow = createToolSkillAgentChain();
-        it('should alternate between tool, agent, and skill nodes', () => {
-            const toolNodes = workflow.nodes.filter(n => n.type === 'tool');
-            const agentNodes = workflow.nodes.filter(n => n.type === 'agent');
-            const skillNodes = workflow.nodes.filter(n => n.type === 'skill');
-            expect(toolNodes.length).toBe(2); // fetch and validate
-            expect(agentNodes.length).toBe(2); // understand and reasoning
-            expect(skillNodes.length).toBe(2); // process and enhance
-        });
-        it('should maintain execution order', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            expect(results.size).toBe(6);
-            // Verify tool → agent → skill chain
-            const toolResult = results.get('fetch-raw-data');
-            const agentResult = results.get('understand-context');
-            const skillResult = results.get('process-with-skill');
-            expect(toolResult).toBeDefined();
-            expect(agentResult).toBeDefined();
-            expect(skillResult).toBeDefined();
-        });
-    });
-    describe('Parallel Tool-Agent Branches', () => {
-        const workflow = createParallelToolAgentWorkflow();
-        it('should have parallel tool-agent pairs', () => {
-            const toolNodes = workflow.nodes.filter(n => n.type === 'tool');
-            const agentNodes = workflow.nodes.filter(n => n.type === 'agent');
-            expect(toolNodes.length).toBeGreaterThan(3); // start + 3 branch tools + output
-            expect(agentNodes.length).toBe(4); // 3 branch agents + 1 aggregator
-        });
-        it('should have merge node after parallel branches', () => {
-            const mergeNode = workflow.nodes.find(n => n.id === 'merge-agents');
-            expect(mergeNode.type).toBe('merge');
-            expect(mergeNode.depends_on).toContain('agent-a');
-            expect(mergeNode.depends_on).toContain('agent-b');
-            expect(mergeNode.depends_on).toContain('agent-c');
-        });
-        it('should execute all parallel branches', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            expect(results.has('tool-a')).toBe(true);
-            expect(results.has('agent-a')).toBe(true);
-            expect(results.has('tool-b')).toBe(true);
-            expect(results.has('agent-b')).toBe(true);
-            expect(results.has('merge-agents')).toBe(true);
-            expect(results.has('aggregate-results')).toBe(true);
-        });
-    });
-    describe('Diamond Pattern Workflow', () => {
-        const workflow = createDiamondWorkflow();
-        it('should have classic diamond structure', () => {
-            // A is the starting point
-            const aNode = workflow.nodes.find(n => n.id === 'A');
-            expect(aNode.depends_on).toBeDefined();
-            expect(aNode.depends_on.length).toBe(0);
-            // B1, B2, B3 all depend on A
-            const b1Node = workflow.nodes.find(n => n.id === 'B1');
-            const b2Node = workflow.nodes.find(n => n.id === 'B2');
-            const b3Node = workflow.nodes.find(n => n.id === 'B3');
-            expect(b1Node.depends_on).toContain('A');
-            expect(b2Node.depends_on).toContain('A');
-            expect(b3Node.depends_on).toContain('A');
-            // C depends on all B nodes
-            const cNode = workflow.nodes.find(n => n.id === 'C');
-            expect(cNode.depends_on).toBeDefined();
-            expect(cNode.depends_on).toContain('B1');
-            expect(cNode.depends_on).toContain('B2');
-            expect(cNode.depends_on).toContain('B3');
-            // D depends on C
-            const dNode = workflow.nodes.find(n => n.id === 'D');
-            expect(dNode.depends_on).toContain('C');
-        });
-        it('should have 6 nodes total', () => {
-            expect(workflow.nodes).toHaveLength(6);
-        });
-        it('should execute diamond pattern correctly', () => {
-            const results = executeWorkflowSync(workflow, { test: 'data' }, executor);
-            // All nodes should be executed
-            expect(results.has('A')).toBe(true);
-            expect(results.has('B1')).toBe(true);
-            expect(results.has('B2')).toBe(true);
-            expect(results.has('B3')).toBe(true);
-            expect(results.has('C')).toBe(true);
-            expect(results.has('D')).toBe(true);
-        });
-        it('should merge results at C node', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            const cResult = results.get('C');
-            expect(cResult).toBeDefined();
-        });
-    });
-    describe('Conditional Execution Workflow', () => {
-        const workflow = createConditionalWorkflow();
-        it('should have conditional branching', () => {
-            const checkNode = workflow.nodes.find(n => n.id === 'check-mode');
-            expect(checkNode.type).toBe('condition');
-            const modeA1 = workflow.nodes.find(n => n.id === 'mode-a-1');
-            const modeB1 = workflow.nodes.find(n => n.id === 'mode-b-1');
-            expect(modeA1.depends_on).toContain('check-mode');
-            expect(modeB1.depends_on).toContain('check-mode');
-        });
-        it('should merge conditional paths', () => {
-            const mergeNode = workflow.nodes.find(n => n.id === 'merge-cond');
-            expect(mergeNode.depends_on).toBeDefined();
-            expect(mergeNode.depends_on).toContain('mode-a-2');
-            expect(mergeNode.depends_on).toContain('mode-b-2');
-        });
-        it('should execute conditional nodes', () => {
-            const results = executeWorkflowSync(workflow, { mode: 'A' }, executor);
-            expect(results.has('check-mode')).toBe(true);
-            const checkResult = results.get('check-mode');
-            expect(checkResult).toBeDefined();
-            expect(checkResult.conditionMet).toBe(true);
-        });
-    });
-    describe('Template Variable Workflow', () => {
-        const workflow = createTemplateVariableWorkflow();
-        it('should have template variables in node configs', () => {
-            const initNode = workflow.nodes.find(n => n.id === 'init');
-            expect(initNode.config.message).toContain('{{input.greeting}}');
-            const processNode = workflow.nodes.find(n => n.id === 'process');
-            expect(processNode.config.expression).toContain('{{init.result}}');
-            expect(processNode.config.expression).toContain('{{input.value}}');
-        });
-        it('should have condition with template variables', () => {
-            const validateNode = workflow.nodes.find(n => n.id === 'validate');
-            expect(validateNode.config.condition).toContain('{{process.result}}');
-            expect(validateNode.config.condition).toContain('{{input.threshold}}');
-        });
-    });
-    describe('Complex Dependency Graph Workflow', () => {
-        const workflow = createComplexDependencyWorkflow();
-        it('should have multiple entry points', () => {
-            const entry1 = workflow.nodes.find(n => n.id === 'entry-1');
-            const entry2 = workflow.nodes.find(n => n.id === 'entry-2');
-            expect(entry1.depends_on).toBeDefined();
-            expect(entry1.depends_on.length).toBe(0);
-            expect(entry2.depends_on).toBeDefined();
-            expect(entry2.depends_on.length).toBe(0);
-        });
-        it('should have cross-branch dependencies', () => {
-            const crossDep = workflow.nodes.find(n => n.id === 'cross-dep');
-            expect(crossDep.depends_on).toBeDefined();
-            expect(crossDep.depends_on).toContain('branch-1a');
-            expect(crossDep.depends_on).toContain('branch-2a');
-        });
-        it('should handle complex merge patterns', () => {
-            const mergeNode = workflow.nodes.find(n => n.id === 'merge-1');
-            expect(mergeNode.depends_on).toBeDefined();
-            expect(mergeNode.depends_on).toHaveLength(3);
-        });
-        it('should execute complex workflow correctly', () => {
-            const results = executeWorkflowSync(workflow, {}, executor);
-            // entry-1, entry-2, branch-1a, branch-1b, branch-2a, branch-2b, cross-dep, merge-1, final = 9 nodes
-            expect(results.size).toBe(9);
-        });
-    });
-    // ==================== Retry Logic Tests ====================
-    describe('Retry Configuration', () => {
-        it('should configure retry with exponential backoff', () => {
-            const workflow = createDataProcessingWorkflow();
-            const retryNode = workflow.nodes.find(n => n.id === 'process-users');
-            expect(retryNode.retry).toBeDefined();
-            expect(retryNode.retry?.max_attempts).toBe(3);
-            expect(retryNode.retry?.backoff).toBe('exponential');
-            expect(retryNode.retry?.initial_delay).toBe(1000);
-        });
-        it('should configure retry with fixed backoff', () => {
-            const workflow = createParallelProcessingWorkflow();
-            const retryNode = workflow.nodes.find(n => n.id === 'task-b3');
-            expect(retryNode.retry).toBeDefined();
-            expect(retryNode.retry?.backoff).toBe('fixed');
-            expect(retryNode.retry?.initial_delay).toBe(500);
-        });
-        it('should have retry node in diamond workflow', () => {
-            const workflow = createDiamondWorkflow();
-            const retryNode = workflow.nodes.find(n => n.id === 'C');
-            expect(retryNode.retry).toBeDefined();
-            expect(retryNode.retry?.max_attempts).toBe(2);
-        });
-    });
-    // ==================== Workflow Validation Tests ====================
-    describe('Workflow Validation', () => {
-        it('should validate workflow with all required fields', () => {
-            const workflow = createDataProcessingWorkflow();
-            // Should have name
-            expect(workflow.name).toBeTruthy();
-            // Should have at least one node
-            expect(workflow.nodes.length).toBeGreaterThan(0);
-            // All nodes should have id and type
-            for (const node of workflow.nodes) {
-                expect(node.id).toBeTruthy();
-                expect(node.type).toBeTruthy();
-            }
-        });
-        it('should have valid dependency references', () => {
-            const workflow = createDataProcessingWorkflow();
-            const nodeIds = new Set(workflow.nodes.map(n => n.id));
-            for (const node of workflow.nodes) {
-                if (node.depends_on) {
-                    for (const depId of node.depends_on) {
-                        expect(nodeIds.has(depId)).toBe(true);
-                    }
-                }
-            }
-        });
-        it('should detect circular dependencies', () => {
-            const circularWorkflow = {
-                name: 'circular',
-                nodes: [
-                    { id: 'a', type: 'tool', config: {}, depends_on: ['c'] },
-                    { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-                    { id: 'c', type: 'tool', config: {}, depends_on: ['b'] },
-                ],
-            };
-            expect(() => topologicalSort(circularWorkflow)).toThrow();
-        });
-    });
-    // ==================== Schema Validation Tests ====================
-    describe('Schema Validation', () => {
-        it('should validate NodeDefinition schema', () => {
-            const NodeDefinitionSchema = z.object({
-                id: z.string().min(1),
-                type: z.string().min(1),
-                name: z.string().optional(),
-                config: z.record(z.string(), z.unknown()).optional(),
-                depends_on: z.array(z.string()).optional(),
-                condition: z.string().optional(),
-                retry: z.object({
-                    max_attempts: z.number().min(1),
-                    backoff: z.enum(['fixed', 'exponential']),
-                    initial_delay: z.number().min(0),
-                }).optional(),
-                timeout: z.number().optional(),
-            });
-            const validNode = {
-                id: 'test-node',
-                type: 'tool',
-                name: 'Test Node',
-                config: { tool: 'test' },
-                depends_on: ['dep1'],
-                retry: { max_attempts: 3, backoff: 'exponential', initial_delay: 1000 },
-            };
-            const result = NodeDefinitionSchema.safeParse(validNode);
-            expect(result.success).toBe(true);
-        });
-        it('should reject invalid retry config', () => {
-            const RetryConfigSchema = z.object({
-                max_attempts: z.number().min(1),
-                backoff: z.enum(['fixed', 'exponential']),
-                initial_delay: z.number().min(0),
-            });
-            const invalidConfig = { max_attempts: 0, backoff: 'invalid', initial_delay: -100 };
-            const result = RetryConfigSchema.safeParse(invalidConfig);
-            expect(result.success).toBe(false);
-        });
-        it('should validate WorkflowDefinition schema', () => {
-            const WorkflowDefinitionSchema = z.object({
-                name: z.string().min(1),
-                version: z.string().default('1.0'),
-                description: z.string().optional(),
-                nodes: z.array(z.object({
-                    id: z.string().min(1),
-                    type: z.string().min(1),
-                })).min(1),
-                entry: z.union([z.string(), z.array(z.string())]).default('__default_entry__'),
-            });
-            const validWorkflow = {
-                name: 'test-workflow',
-                nodes: [{ id: 'n1', type: 'tool' }],
-            };
-            const result = WorkflowDefinitionSchema.safeParse(validWorkflow);
-            expect(result.success).toBe(true);
-            expect(result.data?.version).toBe('1.0');
-        });
-    });
-});
-// ==================== Topological Sort Tests ====================
-describe('Topological Sort', () => {
-    it('should sort nodes in dependency order', () => {
-        const workflow = createDiamondWorkflow();
-        const order = topologicalSort(workflow);
-        // A should come before B1, B2, B3
-        expect(order.indexOf('A')).toBeLessThan(order.indexOf('B1'));
-        expect(order.indexOf('A')).toBeLessThan(order.indexOf('B2'));
-        expect(order.indexOf('A')).toBeLessThan(order.indexOf('B3'));
-        // B* should come before C
-        expect(order.indexOf('B1')).toBeLessThan(order.indexOf('C'));
-        expect(order.indexOf('B2')).toBeLessThan(order.indexOf('C'));
-        expect(order.indexOf('B3')).toBeLessThan(order.indexOf('C'));
-        // C should come before D
-        expect(order.indexOf('C')).toBeLessThan(order.indexOf('D'));
-    });
-    it('should handle parallel branches', () => {
-        const workflow = createParallelProcessingWorkflow();
-        const order = topologicalSort(workflow);
-        // Entry should be first
-        expect(order[0]).toBe('entry');
-        // All task-* should come after entry
-        const taskNodes = order.filter(id => id.startsWith('task-'));
-        expect(taskNodes.length).toBeGreaterThan(0);
-        // Verify dependencies are maintained
-        for (const node of workflow.nodes) {
-            const nodeIndex = order.indexOf(node.id);
-            for (const depId of node.depends_on || []) {
-                expect(order.indexOf(depId)).toBeLessThan(nodeIndex);
-            }
-        }
-    });
-    it('should throw on circular dependency', () => {
-        const circularWorkflow = {
-            name: 'circular',
-            nodes: [
-                { id: 'a', type: 'tool', config: {}, depends_on: ['b'] },
-                { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-            ],
-        };
-        expect(() => topologicalSort(circularWorkflow)).toThrow('Circular dependency detected');
-    });
-});
-// ==================== Performance Tests ====================
-describe('Workflow Performance', () => {
-    it('should handle large parallel execution', () => {
-        const nodes = [
-            { id: 'start', type: 'tool', config: { tool: 'echo' } },
-        ];
-        // Create 20 parallel nodes
-        for (let i = 0; i < 20; i++) {
-            nodes.push({
-                id: `parallel-${i}`,
-                type: 'tool',
-                config: { tool: 'calculator' },
-                depends_on: ['start'],
-            });
-        }
-        // Merge all parallel results
-        nodes.push({
-            id: 'merge',
-            type: 'merge',
-            config: { strategy: 'collect' },
-            depends_on: nodes.slice(1).map(n => n.id),
-        });
-        const workflow = {
-            name: 'large-parallel',
-            nodes,
-        };
-        const order = topologicalSort(workflow);
-        expect(order.length).toBe(22); // 1 start + 20 parallel + 1 merge
-    });
-    it('should handle deep dependency chains', () => {
-        const nodes = [];
-        // Create 50-node deep chain
-        for (let i = 0; i < 50; i++) {
-            nodes.push({
-                id: `node-${i}`,
-                type: 'tool',
-                config: { tool: 'echo' },
-                depends_on: i > 0 ? [`node-${i - 1}`] : [],
-            });
-        }
-        const workflow = {
-            name: 'deep-chain',
-            nodes,
-        };
-        const order = topologicalSort(workflow);
-        // Should maintain order
-        for (let i = 1; i < order.length; i++) {
-            expect(order.indexOf(`node-${i - 1}`)).toBeLessThan(order.indexOf(`node-${i}`));
-        }
-    });
-    it('should execute large workflow efficiently', () => {
-        const nodes = [
-            { id: 'start', type: 'tool', config: { tool: 'echo' } },
-        ];
-        for (let i = 0; i < 10; i++) {
-            nodes.push({
-                id: `node-${i}`,
-                type: 'tool',
-                config: { tool: 'calculator' },
-                depends_on: i === 0 ? ['start'] : [`node-${i - 1}`],
-            });
-        }
-        const workflow = {
-            name: 'large-chain',
-            nodes,
-        };
-        const executor = new SyncWorkflowExecutor();
-        const start = Date.now();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        const duration = Date.now() - start;
-        expect(results.size).toBe(11);
-        expect(duration).toBeLessThan(100); // Should complete in under 100ms
-    });
-});
-// ==================== Edge Cases ====================
-describe('Workflow Edge Cases', () => {
-    it('should handle single node workflow', () => {
-        const workflow = {
-            name: 'single-node',
-            nodes: [{ id: 'only', type: 'tool', config: {} }],
-        };
-        const order = topologicalSort(workflow);
-        expect(order).toEqual(['only']);
-        const executor = new SyncWorkflowExecutor();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        expect(results.size).toBe(1);
-        expect(results.get('only')).toBeDefined();
-    });
-    it('should handle nodes with multiple dependencies', () => {
-        const workflow = {
-            name: 'multi-dep',
-            nodes: [
-                { id: 'a', type: 'tool', config: {} },
-                { id: 'b', type: 'tool', config: {} },
-                { id: 'c', type: 'tool', config: {} },
-                { id: 'd', type: 'tool', config: {}, depends_on: ['a', 'b', 'c'] },
-            ],
-        };
-        const order = topologicalSort(workflow);
-        const dIndex = order.indexOf('d');
-        expect(order.indexOf('a')).toBeLessThan(dIndex);
-        expect(order.indexOf('b')).toBeLessThan(dIndex);
-        expect(order.indexOf('c')).toBeLessThan(dIndex);
-    });
-    it('should handle multiple entry points', () => {
-        const workflow = {
-            name: 'multi-entry',
-            entry: ['a', 'b'],
-            nodes: [
-                { id: 'a', type: 'tool', config: {} },
-                { id: 'b', type: 'tool', config: {} },
-                { id: 'c', type: 'tool', config: {}, depends_on: ['a', 'b'] },
-            ],
-        };
-        const order = topologicalSort(workflow);
-        expect(order.includes('a')).toBe(true);
-        expect(order.includes('b')).toBe(true);
-        expect(order.indexOf('c')).toBeGreaterThan(order.indexOf('a'));
-        expect(order.indexOf('c')).toBeGreaterThan(order.indexOf('b'));
-    });
-    it('should handle optional fields in nodes', () => {
-        const minimalNode = {
-            id: 'minimal',
-            type: 'tool',
-        };
-        const NodeDefinitionSchema = z.object({
-            id: z.string().min(1),
-            type: z.string().min(1),
-            name: z.string().optional(),
-            config: z.record(z.string(), z.unknown()).optional(),
-            depends_on: z.array(z.string()).optional(),
-        });
-        const result = NodeDefinitionSchema.safeParse(minimalNode);
-        expect(result.success).toBe(true);
-    });
-    it('should handle empty depends_on array', () => {
-        const workflow = {
-            name: 'empty-deps',
-            nodes: [
-                { id: 'a', type: 'tool', config: {}, depends_on: [] },
-                { id: 'b', type: 'tool', config: {}, depends_on: ['a'] },
-            ],
-        };
-        const order = topologicalSort(workflow);
-        expect(order.indexOf('a')).toBeLessThan(order.indexOf('b'));
-    });
-    it('should handle nodes without config', () => {
-        const workflow = {
-            name: 'no-config',
-            nodes: [
-                { id: 'a', type: 'tool' },
-                { id: 'b', type: 'tool', depends_on: ['a'] },
-            ],
-        };
-        const executor = new SyncWorkflowExecutor();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        expect(results.get('a')).toBeDefined();
-        expect(results.get('b')).toBeDefined();
-    });
-});
-// ==================== Execution Trace Tests ====================
-describe('Execution Trace', () => {
-    it('should track execution order', () => {
-        const workflow = createDiamondWorkflow();
-        const executor = new SyncWorkflowExecutor();
-        executeWorkflowSync(workflow, {}, executor);
-        const trace = executor.getTrace();
-        expect(trace.executionOrder).toEqual(['A', 'B1', 'B2', 'B3', 'C', 'D']);
-    });
-    it('should track node execution status', () => {
-        const workflow = createDiamondWorkflow();
-        const executor = new SyncWorkflowExecutor();
-        executeWorkflowSync(workflow, {}, executor);
-        const trace = executor.getTrace();
-        for (const entry of trace.nodes.values()) {
-            expect(entry.status).toBe('completed');
-            expect(entry.startTime).toBeDefined();
-            expect(entry.endTime).toBeDefined();
-            expect(entry.endTime).toBeGreaterThanOrEqual(entry.startTime);
-        }
-    });
-    it('should record input for each node', () => {
-        const workflow = createDataProcessingWorkflow();
-        const executor = new SyncWorkflowExecutor();
-        const input = { generateReport: true, test: 'value' };
-        executeWorkflowSync(workflow, input, executor);
-        const trace = executor.getTrace();
-        const initEntry = trace.nodes.get('init');
-        expect(initEntry?.input).toEqual(input);
-    });
-    it('should record output for each node', () => {
-        const workflow = createDiamondWorkflow();
-        const executor = new SyncWorkflowExecutor();
-        executeWorkflowSync(workflow, {}, executor);
-        const trace = executor.getTrace();
-        for (const [nodeId, entry] of trace.nodes) {
-            expect(entry.output).toBeDefined();
-        }
-    });
-});
-// ==================== Merge Node Tests ====================
-describe('Merge Node Behavior', () => {
-    it('should collect all dependency outputs', () => {
-        const workflow = {
-            name: 'merge-test',
-            nodes: [
-                { id: 'a', type: 'tool', config: { tool: 'calculator' } },
-                { id: 'b', type: 'tool', config: { tool: 'calculator' } },
-                { id: 'c', type: 'tool', config: { tool: 'calculator' } },
-                {
-                    id: 'merge',
-                    type: 'merge',
-                    config: { strategy: 'collect' },
-                    depends_on: ['a', 'b', 'c'],
-                },
-            ],
-        };
-        const executor = new SyncWorkflowExecutor();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        const mergeResult = results.get('merge');
-        expect(mergeResult).toBeDefined();
-        expect(mergeResult.merged).toBe(true);
-        expect(mergeResult.inputs).toBeDefined();
-        expect(mergeResult.inputs.a).toBeDefined();
-        expect(mergeResult.inputs.b).toBeDefined();
-        expect(mergeResult.inputs.c).toBeDefined();
-    });
-    it('should handle merge with different strategies', () => {
-        const mergeStrategies = ['collect', 'merge', 'concat', 'zip'];
-        for (const strategy of mergeStrategies) {
-            const workflow = {
-                name: `merge-${strategy}`,
-                nodes: [
-                    { id: 'a', type: 'tool', config: { tool: 'calculator' } },
-                    { id: 'b', type: 'tool', config: { tool: 'calculator' } },
-                    {
-                        id: 'merge',
-                        type: 'merge',
-                        config: { strategy },
-                        depends_on: ['a', 'b'],
-                    },
-                ],
-            };
-            const executor = new SyncWorkflowExecutor();
-            const results = executeWorkflowSync(workflow, {}, executor);
-            const mergeResult = results.get('merge');
-            expect(mergeResult).toBeDefined();
-            expect(mergeResult.mergeStrategy).toBe(strategy);
-        }
-    });
-});
-// ==================== Condition Node Tests ====================
-describe('Condition Node Behavior', () => {
-    it('should evaluate true condition', () => {
-        const workflow = {
-            name: 'condition-test',
-            nodes: [
-                { id: 'check', type: 'condition', config: { condition: 'true' } },
-                { id: 'output', type: 'tool', config: { tool: 'echo' }, depends_on: ['check'] },
-            ],
-        };
-        const executor = new SyncWorkflowExecutor();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        const checkResult = results.get('check');
-        expect(checkResult).toBeDefined();
-        expect(checkResult.conditionMet).toBe(true);
-    });
-    it('should evaluate template condition', () => {
-        const workflow = {
-            name: 'condition-template',
-            nodes: [
-                {
-                    id: 'check',
-                    type: 'condition',
-                    config: { condition: '{{merge-data.valid}}' },
-                },
-                { id: 'output', type: 'tool', config: { tool: 'echo' }, depends_on: ['check'] },
-            ],
-        };
-        const executor = new SyncWorkflowExecutor();
-        const results = executeWorkflowSync(workflow, {}, executor);
-        const checkResult = results.get('check');
-        expect(checkResult).toBeDefined();
-        expect(checkResult.conditionMet).toBe(true); // Template conditions default to true
-        expect(checkResult.evaluatedCondition).toBe('{{merge-data.valid}}');
-    });
-});
-//# sourceMappingURL=complex-workflow.integration.test.js.map