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

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

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

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

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

@@ -0,0 +1,216 @@
+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

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