@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

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

@@ -0,0 +1,1588 @@
+/**
+ * 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