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

package/dist/core/src/env/workflow/utils/template-resolver.js

@@ -1,359 +0,0 @@
-/**
- * @fileoverview Template Resolver - Unified template resolution for workflow nodes
- *
- * This module provides a unified template resolution system for workflow nodes.
- * Templates are in the format {{path}} where path can reference:
- *
- * - Input variables: {{input.key}} or {{input.key.nested}}
- * - Node outputs: {{nodeId}} or {{nodeId.output}} or {{nodeId.output.path}}
- * - With prefix: {{nodes.nodeId}} or {{nodes.nodeId.output.path}}
- *
- * @example
- * ```typescript
- * const resolver = new TemplateResolver({
- *   input: { query: 'weather' },
- *   previousOutputs: new Map([
- *     ['fetch', { data: { temp: 25, condition: 'sunny' } }]
- *   ])
- * });
- *
- * resolver.resolve('Weather in {{input.query}}: {{nodes.fetch.data.condition}}');
- * // => 'Weather in weather: sunny'
- * ```
- */
-// ============================================================================
-// TemplateResolver Class
-// ============================================================================
-/**
- * TemplateResolver
- *
- * Resolves template strings that reference workflow inputs and node outputs.
- */
-export class TemplateResolver {
-    input;
-    previousOutputs;
-    constructor(options = {}) {
-        this.input = options.input ?? {};
-        this.previousOutputs = options.previousOutputs ?? new Map();
-    }
-    /**
-     * Create a TemplateResolver from NodeExecutionContext
-     *
-     * @param context - Node execution context
-     * @returns TemplateResolver instance
-     */
-    static fromContext(context) {
-        return new TemplateResolver({
-            input: context.input,
-            previousOutputs: context.previousOutputs,
-        });
-    }
-    /**
-     * Resolve template references in an input value.
-     *
-     * Handles:
-     * - Primitive values (returned as-is)
-     * - Objects (recursively resolved)
-     * - Arrays (recursively resolved)
-     * - Strings (template resolution)
-     *
-     * Key behavior for template strings:
-     * - If the string is a pure template reference (e.g., "{{nodes.fetch}}"),
-     *   the resolved value is returned as-is (preserving objects/arrays)
-     * - If the string contains text + templates (e.g., "Hello {{name}}"),
-     *   returns a string with interpolated values
-     *
-     * @param input - Input value that may contain template strings
-     * @returns Input with template references resolved
-     */
-    resolveValue(input) {
-        if (input === null || input === undefined) {
-            return input;
-        }
-        if (typeof input === 'string') {
-            // Check if this is a pure template reference (no surrounding text)
-            const pureTemplate = this.extractPureTemplate(input);
-            if (pureTemplate) {
-                // Pure template reference - resolve and return value as-is (preserve objects/arrays)
-                return this.resolvePureTemplate(pureTemplate);
-            }
-            // Mixed text + templates - return resolved string
-            return this.resolveString(input);
-        }
-        if (Array.isArray(input)) {
-            return input.map(item => this.resolveValue(item));
-        }
-        if (typeof input === 'object') {
-            const resolved = {};
-            for (const [key, value] of Object.entries(input)) {
-                resolved[key] = this.resolveValue(value);
-            }
-            return resolved;
-        }
-        // Return primitive values as-is
-        return input;
-    }
-    /**
-     * Check if a string is a pure template reference (starts with {{ and ends with }})
-     * @param str - String to check
-     * @returns The template content if pure, null otherwise
-     */
-    extractPureTemplate(str) {
-        const trimmed = str.trim();
-        if (trimmed.startsWith('{{') && trimmed.endsWith('}}') && trimmed.length > 4) {
-            // Extract content between {{ and }}
-            const content = trimmed.slice(2, -2).trim();
-            // Check there's no other text (except the template patterns themselves)
-            // This ensures we don't treat "Hello {{name}}" as pure template
-            if (!content.includes('{{') && !content.includes('}}')) {
-                return content;
-            }
-        }
-        return null;
-    }
-    /**
-     * Resolve a pure template reference and return the value as-is.
-     * @param templateContent - Content between {{ and }}
-     * @returns The resolved value (may be object, array, or primitive)
-     */
-    resolvePureTemplate(templateContent) {
-        // Try to resolve the template
-        const value = this.resolveTemplateContent(templateContent);
-        return value;
-    }
-    /**
-     * Resolve template content (the part inside {{ }}) and return the value.
-     * @param templateContent - The path to resolve (e.g., "input.key", "nodes.fetch.data")
-     * @returns The resolved value
-     */
-    resolveTemplateContent(templateContent) {
-        const trimmed = templateContent.trim();
-        // Pattern 1: {{input.key}} or {{input.key.nested}}
-        if (trimmed.startsWith('input.')) {
-            return this.getNestedValue(this.input, trimmed.slice(6)); // "input." is 6 chars
-        }
-        // Pattern 2: {{nodes.nodeId}} or {{nodes.nodeId.output}}
-        if (trimmed.startsWith('nodes.')) {
-            return this.resolveNodePath(trimmed.slice(6)); // "nodes." is 6 chars
-        }
-        // Pattern 3: Bare nodeId (backward compatibility)
-        // Skip reserved keywords
-        if (trimmed !== 'input' && trimmed !== 'nodes') {
-            const segments = trimmed.split('.');
-            const nodeId = segments[0];
-            const restPath = segments.slice(1).join('.') || undefined;
-            return this.resolveNodePath(`${nodeId}${restPath ? '.' + restPath : ''}`);
-        }
-        return undefined;
-    }
-    /**
-     * Resolve a single template string.
-     *
-     * Supports patterns:
-     * - {{input.key}} - Input variable
-     * - {{nodeId}} - Node's entire output
-     * - {{nodeId.output}} - Node's output property
-     * - {{nodeId.output.path}} - Node's nested output property
-     * - {{nodes.nodeId}} - Node's entire output (with prefix)
-     * - {{nodes.nodeId.output.path}} - Node's nested property (with prefix)
-     *
-     * @param template - Template string to resolve
-     * @returns Resolved string
-     */
-    resolveString(template) {
-        if (!template || typeof template !== 'string') {
-            return template;
-        }
-        let resolved = template;
-        // Pattern 1: {{input.key}} or {{input.key.nested}}
-        resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-            const value = this.getNestedValue(this.input, path);
-            return this.stringify(value, match);
-        });
-        // Pattern 2: {{nodes.nodeId}} or {{nodes.nodeId.output.path}}
-        // Also handles {{nodes.nodeId.output}} format
-        resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-            const value = this.resolveNodePath(path);
-            return this.stringify(value, match);
-        });
-        // Pattern 3: {{nodeId}} or {{nodeId.output}} or {{nodeId.output.path}}
-        // This is for backward compatibility with SkillNode's bare nodeId format
-        // Only matches if not already matched by nodes. pattern
-        // We need to be careful not to match {{input.xxx}} patterns
-        // Supports node IDs with alphanumeric, underscore, hyphen characters
-        resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_-]*)(?:\.([^}]+))?\}\}/g, (match, nodeId, path) => {
-            // Skip if this looks like an input reference without the prefix
-            // This is a heuristic: 'input' as first segment is handled above
-            if (nodeId === 'input') {
-                return match;
-            }
-            // Skip 'nodes' prefix (already handled above)
-            if (nodeId === 'nodes') {
-                return match;
-            }
-            const value = this.resolveNodePath(`${nodeId}${path ? '.' + path : ''}`);
-            return this.stringify(value, match);
-        });
-        return resolved;
-    }
-    /**
-     * Resolve a node output path.
-     *
-     * @param path - Path like "nodeId" or "nodeId.output" or "nodeId.output.path"
-     * @returns The resolved value or undefined
-     */
-    resolveNodePath(path) {
-        const segments = path.split('.');
-        const nodeId = segments[0];
-        if (!nodeId) {
-            return undefined;
-        }
-        // Get node output from previous outputs
-        // Try exact match first, then try normalized versions (hyphen <-> underscore)
-        let value = this.previousOutputs.get(nodeId);
-        if (value === undefined) {
-            // Try normalized versions for flexibility
-            // This handles cases where workflow defines node with underscore but template uses hyphen, or vice versa
-            const normalizedUnderscore = nodeId.replace(/-/g, '_');
-            const normalizedHyphen = nodeId.replace(/_/g, '-');
-            if (normalizedUnderscore !== nodeId) {
-                value = this.previousOutputs.get(normalizedUnderscore);
-            }
-            if (value === undefined && normalizedHyphen !== nodeId) {
-                value = this.previousOutputs.get(normalizedHyphen);
-            }
-        }
-        if (value === undefined) {
-            return undefined;
-        }
-        // If no additional path (bare nodeId), handle AgentNode output format
-        if (segments.length === 1) {
-            // Special handling for AgentNode output format: { result, metadata }
-            // If output has this shape, extract the result
-            if (value && typeof value === 'object' && 'result' in value && !('nodes' in value)) {
-                value = value.result;
-            }
-            return value;
-        }
-        // Navigate nested path
-        // Special handling for AgentNode output format: { result, metadata }
-        // If path starts with 'result' or 'output', try to extract from wrapper
-        const secondSegment = segments[1];
-        if (secondSegment === 'result' || secondSegment === 'output') {
-            // Check if current value is an AgentNode-style wrapper
-            if (value && typeof value === 'object' && 'result' in value) {
-                value = value.result;
-                if (segments.length === 2) {
-                    // Path was {{nodeId.result}} - return the result directly
-                    return value;
-                }
-                // Skip the 'result' segment and continue navigating
-                for (let i = 2; i < segments.length; i++) {
-                    if (value === null || value === undefined) {
-                        return undefined;
-                    }
-                    value = value[segments[i]];
-                }
-                return value;
-            }
-        }
-        // Standard nested path navigation
-        for (let i = 1; i < segments.length; i++) {
-            if (value === null || value === undefined) {
-                return undefined;
-            }
-            value = value[segments[i]];
-        }
-        return value;
-    }
-    /**
-     * Get a nested value from an object using dot notation.
-     *
-     * @param obj - Object to traverse
-     * @param path - Dot-separated path
-     * @returns The nested value or undefined
-     */
-    getNestedValue(obj, path) {
-        if (!obj || !path) {
-            return undefined;
-        }
-        const segments = path.split('.');
-        let current = obj;
-        for (const segment of segments) {
-            if (current === null || current === undefined) {
-                return undefined;
-            }
-            if (typeof current !== 'object') {
-                return undefined;
-            }
-            current = current[segment];
-        }
-        return current;
-    }
-    /**
-     * Convert a value to string, or return the original template if value is undefined.
-     */
-    stringify(value, originalTemplate) {
-        if (value === undefined) {
-            return originalTemplate;
-        }
-        if (typeof value === 'string') {
-            return value;
-        }
-        if (value === null) {
-            return 'null';
-        }
-        return JSON.stringify(value);
-    }
-    /**
-     * Check if a string contains template references.
-     *
-     * @param str - String to check
-     * @returns True if the string contains template references
-     */
-    containsTemplates(str) {
-        if (typeof str !== 'string') {
-            return false;
-        }
-        return /\{\{[^}]+\}\}/.test(str);
-    }
-    /**
-     * Extract all template references from a string.
-     *
-     * @param str - String to extract from
-     * @returns Array of template references
-     */
-    extractTemplates(str) {
-        if (typeof str !== 'string') {
-            return [];
-        }
-        const matches = str.match(/\{\{[^}]+\}\}/g);
-        return matches ?? [];
-    }
-}
-// ============================================================================
-// Convenience Functions
-// ============================================================================
-/**
- * Resolve template references in input using context.
- *
- * @param input - Input value with potential templates
- * @param context - Node execution context
- * @returns Resolved input
- */
-export function resolveTemplates(input, context) {
-    const resolver = TemplateResolver.fromContext(context);
-    return resolver.resolveValue(input);
-}
-/**
- * Resolve a template string using context.
- *
- * @param template - Template string
- * @param context - Node execution context
- * @returns Resolved string
- */
-export function resolveTemplateString(template, context) {
-    const resolver = TemplateResolver.fromContext(context);
-    return resolver.resolveString(template);
-}
-//# sourceMappingURL=template-resolver.js.map

package/dist/core/src/env/workflow/utils/template-resolver.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=template-resolver.test.d.ts.map

package/dist/core/src/env/workflow/utils/template-resolver.test.js

@@ -1,216 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest';
-import { TemplateResolver } from "./template-resolver.js";
-describe('TemplateResolver', () => {
-    let resolver;
-    beforeEach(() => {
-        resolver = new TemplateResolver({
-            input: { query: 'weather', city: 'Beijing' },
-            previousOutputs: new Map([
-                ['fetch', { data: { temp: 25, condition: 'sunny', items: [1, 2, 3] } }],
-                ['process', { result: 'processed', score: 0.95 }],
-                ['agent', { result: { summary: 'Great day!', metadata: { source: 'weather-api' } }, metadata: { tokens: 100 } }],
-            ]),
-        });
-    });
-    describe('resolveString', () => {
-        test('should return primitive values unchanged', () => {
-            expect(resolver.resolveString('hello')).toBe('hello');
-            expect(resolver.resolveString('123')).toBe('123');
-            expect(resolver.resolveString('')).toBe('');
-        });
-        test('should resolve input references with prefix', () => {
-            expect(resolver.resolveString('Query: {{input.query}}')).toBe('Query: weather');
-            expect(resolver.resolveString('City: {{input.city}}')).toBe('City: Beijing');
-        });
-        test('should resolve nested input references', () => {
-            resolver = new TemplateResolver({
-                input: { user: { profile: { name: 'John' } } },
-            });
-            expect(resolver.resolveString('Name: {{input.user.profile.name}}')).toBe('Name: John');
-        });
-        test('should resolve node output with prefix', () => {
-            expect(resolver.resolveString('Condition: {{nodes.fetch}}')).toBe('Condition: {"data":{"temp":25,"condition":"sunny","items":[1,2,3]}}');
-            expect(resolver.resolveString('Temp: {{nodes.fetch.data.temp}}')).toBe('Temp: 25');
-            expect(resolver.resolveString('Condition: {{nodes.fetch.data.condition}}')).toBe('Condition: sunny');
-        });
-        test('should resolve node output without prefix (backward compatibility)', () => {
-            expect(resolver.resolveString('Temp: {{fetch.data.temp}}')).toBe('Temp: 25');
-            expect(resolver.resolveString('Condition: {{fetch.data.condition}}')).toBe('Condition: sunny');
-        });
-        test('should resolve agent node result', () => {
-            // Bare {{agent}} extracts the result field from AgentNode output format
-            expect(resolver.resolveString('Summary: {{agent}}')).toBe('Summary: {"summary":"Great day!","metadata":{"source":"weather-api"}}');
-            // Explicit {{agent.result}} also works
-            expect(resolver.resolveString('Summary: {{agent.result.summary}}')).toBe('Summary: Great day!');
-            // Can also access metadata directly
-            expect(resolver.resolveString('Tokens: {{agent.metadata.tokens}}')).toBe('Tokens: 100');
-        });
-        test('should resolve multiple templates in one string', () => {
-            expect(resolver.resolveString('Query: {{input.query}}, Condition: {{nodes.fetch.data.condition}}'))
-                .toBe('Query: weather, Condition: sunny');
-        });
-        test('should leave unresolved templates unchanged', () => {
-            expect(resolver.resolveString('Missing: {{nodes.nonexistent}}')).toBe('Missing: {{nodes.nonexistent}}');
-            expect(resolver.resolveString('Missing: {{nonexistent}}')).toBe('Missing: {{nonexistent}}');
-        });
-        test('should handle empty template', () => {
-            expect(resolver.resolveString('Empty: {{}}')).toBe('Empty: {{}}');
-        });
-    });
-    describe('resolveValue', () => {
-        test('should resolve string values', () => {
-            expect(resolver.resolveValue('Temperature: {{nodes.fetch.data.temp}}°C'))
-                .toBe('Temperature: 25°C');
-        });
-        test('should resolve object values', () => {
-            const result = resolver.resolveValue({
-                query: '{{input.query}}',
-                temp: '{{nodes.fetch.data.temp}}',
-            });
-            expect(result).toEqual({
-                query: 'weather',
-                temp: 25, // Pure template references preserve original types
-            });
-        });
-        test('should resolve array values', () => {
-            const result = resolver.resolveValue([
-                '{{input.query}}',
-                '{{nodes.fetch.data.condition}}',
-                'static',
-            ]);
-            expect(result).toEqual(['weather', 'sunny', 'static']);
-        });
-        test('should resolve nested structures', () => {
-            const result = resolver.resolveValue({
-                level1: {
-                    level2: '{{input.query}}',
-                    items: ['{{input.city}}', '{{nodes.fetch.data.temp}}'],
-                },
-            });
-            expect(result).toEqual({
-                level1: {
-                    level2: 'weather',
-                    items: ['Beijing', 25], // Pure template references preserve original types
-                },
-            });
-        });
-        test('should handle null and undefined', () => {
-            expect(resolver.resolveValue(null)).toBe(null);
-            expect(resolver.resolveValue(undefined)).toBe(undefined);
-        });
-    });
-    describe('containsTemplates', () => {
-        test('should detect templates in strings', () => {
-            expect(resolver.containsTemplates('{{input.query}}')).toBe(true);
-            expect(resolver.containsTemplates('Query: {{input.query}}')).toBe(true);
-            expect(resolver.containsTemplates('No templates')).toBe(false);
-        });
-        test('should return false for non-strings', () => {
-            expect(resolver.containsTemplates(123)).toBe(false);
-            expect(resolver.containsTemplates(null)).toBe(false);
-        });
-    });
-    describe('extractTemplates', () => {
-        test('should extract all template references', () => {
-            const templates = resolver.extractTemplates('Query: {{input.query}}, Temp: {{nodes.fetch.data.temp}}');
-            expect(templates).toEqual(['{{input.query}}', '{{nodes.fetch.data.temp}}']);
-        });
-        test('should return empty array for strings without templates', () => {
-            expect(resolver.extractTemplates('No templates')).toEqual([]);
-        });
-    });
-    describe('fromContext', () => {
-        test('should create resolver from NodeExecutionContext', () => {
-            const context = {
-                runId: 'run_123',
-                workflowName: 'test-workflow',
-                nodeId: 'test-node',
-                input: { key: 'value' },
-                previousOutputs: new Map([['prev', { out: 'result' }]]),
-                config: {},
-                debug: false,
-                eventBus: {},
-                nodeOutputs: new Map(),
-            };
-            const contextResolver = TemplateResolver.fromContext(context);
-            expect(contextResolver.resolveString('{{input.key}}')).toBe('value');
-            expect(contextResolver.resolveString('{{prev.out}}')).toBe('result');
-        });
-    });
-});
-describe('TemplateResolver Edge Cases', () => {
-    test('should handle complex nested paths', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { a: { b: { c: { d: 'deep value' } } } }],
-            ]),
-        });
-        expect(resolver.resolveString('{{node.a.b.c.d}}')).toBe('deep value');
-    });
-    test('should handle arrays in path', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { items: [{ name: 'item1' }, { name: 'item2' }] }],
-            ]),
-        });
-        expect(resolver.resolveString('{{node.items.0.name}}')).toBe('item1');
-        expect(resolver.resolveString('{{node.items.1.name}}')).toBe('item2');
-    });
-    test('should handle special characters in values', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { special: 'value with "quotes" and \'apostrophes\'' }],
-            ]),
-        });
-        expect(resolver.resolveString('{{node.special}}')).toBe('value with "quotes" and \'apostrophes\'');
-    });
-    test('should handle numeric values', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { count: 42, ratio: 0.5, negative: -10 }],
-            ]),
-        });
-        expect(resolver.resolveString('Count: {{node.count}}')).toBe('Count: 42');
-        expect(resolver.resolveString('Ratio: {{node.ratio}}')).toBe('Ratio: 0.5');
-        expect(resolver.resolveString('Negative: {{node.negative}}')).toBe('Negative: -10');
-    });
-    test('should handle boolean values', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { active: true, deleted: false }],
-            ]),
-        });
-        expect(resolver.resolveString('Active: {{node.active}}')).toBe('Active: true');
-        expect(resolver.resolveString('Deleted: {{node.deleted}}')).toBe('Deleted: false');
-    });
-    test('should handle empty previousOutputs map', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map(),
-        });
-        expect(resolver.resolveString('{{node.output}}')).toBe('{{node.output}}');
-        expect(resolver.resolveString('Missing: {{nodes.nodeId}}')).toBe('Missing: {{nodes.nodeId}}');
-    });
-    test('should handle null values in chain', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { a: null }],
-            ]),
-        });
-        expect(resolver.resolveString('{{node.a.b}}')).toBe('{{node.a.b}}');
-    });
-    test('should handle undefined intermediate values', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map([
-                ['node', { a: undefined }],
-            ]),
-        });
-        expect(resolver.resolveString('{{node.a.b}}')).toBe('{{node.a.b}}');
-    });
-    test('should handle missing node', () => {
-        const resolver = new TemplateResolver({
-            previousOutputs: new Map(),
-        });
-        expect(resolver.resolveString('Value: {{missing.value}}')).toBe('Value: {{missing.value}}');
-    });
-});
-//# sourceMappingURL=template-resolver.test.js.map

package/dist/core/src/env/workflow/utils/validation-rules.d.ts

@@ -1,104 +0,0 @@
-/**
- * Validation Rules for Workflow Recovery
- *
- * Defines types for validation errors, results, and recovery plans.
- */
-/**
- * Validation error types for workflow recovery
- */
-export declare enum ValidationErrorType {
-    /** Variable referenced by node input is missing */
-    MISSING_VARIABLE = "MISSING_VARIABLE",
-    /** Parallel branch is incomplete */
-    INCOMPLETE_PARALLEL = "INCOMPLETE_PARALLEL",
-    /** Condition branch cannot be determined */
-    AMBIGUOUS_BRANCH = "AMBIGUOUS_BRANCH",
-    /** Loop state is lost */
-    LOOP_STATE_LOST = "LOOP_STATE_LOST",
-    /** Nested workflow state is invalid */
-    NESTED_WORKFLOW_INVALID = "NESTED_WORKFLOW_INVALID",
-    /** Node execution state is inconsistent */
-    NODE_STATE_INCONSISTENT = "NODE_STATE_INCONSISTENT",
-    /** Critical dependency is missing */
-    MISSING_DEPENDENCY = "MISSING_DEPENDENCY"
-}
-/**
- * Suggested actions for recovery
- */
-export declare enum SuggestedAction {
-    /** Re-run the workflow from the beginning */
-    RE_RUN = "RE_RUN",
-    /** Confirm with user before proceeding */
-    CONFIRM = "CONFIRM",
-    /** Skip the problematic node */
-    SKIP = "SKIP",
-    /** Provide the missing value */
-    PROVIDE_VALUE = "PROVIDE_VALUE",
-    /** Ignore the warning and proceed */
-    IGNORE = "IGNORE"
-}
-/**
- * Validation error detail
- */
-export interface ValidationError {
-    /** Error type */
-    type: ValidationErrorType;
-    /** Node ID where error occurred */
-    nodeId: string;
-    /** Human-readable error description */
-    description: string;
-    /** Suggested action to resolve */
-    suggestedAction: SuggestedAction;
-    /** Additional context information */
-    context?: Record<string, unknown>;
-}
-/**
- * Result of validation
- */
-export interface ValidationResult {
-    /** Whether the workflow can be safely resumed */
-    isValid: boolean;
-    /** List of validation errors */
-    errors: ValidationError[];
-    /** List of warnings (non-critical issues) */
-    warnings: string[];
-}
-/**
- * Recovery plan for resuming a workflow
- */
-export interface RecoveryPlan {
-    /** Whether the workflow can be resumed */
-    canResume: boolean;
-    /** Node ID where execution should resume */
-    resumePoint: string;
-    /** List of completed node IDs */
-    completedNodes: string[];
-    /** List of pending node IDs */
-    pendingNodes: string[];
-    /** List of node IDs that will be skipped */
-    skippedNodes: string[];
-    /** Validation errors encountered */
-    validationErrors: ValidationError[];
-    /** Human-readable summary */
-    summary: string;
-}
-/**
- * Execution state of a workflow
- */
-export interface ExecutionState {
-    /** Set of completed node IDs */
-    completedNodes: Set<string>;
-    /** Set of in-progress node IDs */
-    inProgressNodes: Set<string>;
-    /** Set of pending node IDs */
-    pendingNodes: Set<string>;
-    /** Map of node ID to output */
-    nodeOutputs: Map<string, unknown>;
-    /** Map of node ID to input */
-    nodeInputs: Map<string, unknown>;
-    /** Map of variable name to value */
-    variables: Map<string, unknown>;
-    /** Loop iteration counts */
-    loopCounts: Map<string, number>;
-}
-//# sourceMappingURL=validation-rules.d.ts.map