@marktoflow/core 2.0.0-alpha.3

package/dist/engine.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Workflow Execution Engine for marktoflow v2.0
+ *
+ * Executes workflow steps with retry logic, variable resolution,
+ * and SDK invocation.
+ */
+import { Workflow, WorkflowStep, ExecutionContext, StepResult, WorkflowResult } from './models.js';
+import { StateStore } from './state.js';
+import { AgentHealthTracker, type FailoverConfig, type FailoverEvent } from './failover.js';
+import { RollbackRegistry } from './rollback.js';
+export interface EngineConfig {
+    /** Default timeout for steps in milliseconds */
+    defaultTimeout?: number;
+    /** Maximum retries for failed steps */
+    maxRetries?: number;
+    /** Base delay for retry backoff in milliseconds */
+    retryBaseDelay?: number;
+    /** Maximum delay for retry backoff in milliseconds */
+    retryMaxDelay?: number;
+    /** Optional rollback registry for rollback error handling */
+    rollbackRegistry?: RollbackRegistry;
+    /** Failover configuration for step execution */
+    failoverConfig?: Partial<FailoverConfig>;
+    /** Optional agent health tracker */
+    healthTracker?: AgentHealthTracker;
+}
+export interface SDKRegistryLike {
+    /** Load an SDK by name */
+    load(sdkName: string): Promise<unknown>;
+    /** Check if SDK is available */
+    has(sdkName: string): boolean;
+}
+export type StepExecutor = (step: WorkflowStep, context: ExecutionContext, sdkRegistry: SDKRegistryLike) => Promise<unknown>;
+export interface EngineEvents {
+    onStepStart?: (step: WorkflowStep, context: ExecutionContext) => void;
+    onStepComplete?: (step: WorkflowStep, result: StepResult) => void;
+    onStepError?: (step: WorkflowStep, error: Error, retryCount: number) => void;
+    onWorkflowStart?: (workflow: Workflow, context: ExecutionContext) => void;
+    onWorkflowComplete?: (workflow: Workflow, result: WorkflowResult) => void;
+}
+export declare class RetryPolicy {
+    readonly maxRetries: number;
+    readonly baseDelay: number;
+    readonly maxDelay: number;
+    readonly exponentialBase: number;
+    readonly jitter: number;
+    constructor(maxRetries?: number, baseDelay?: number, maxDelay?: number, exponentialBase?: number, jitter?: number);
+    /**
+     * Calculate delay for a given retry attempt.
+     */
+    getDelay(attempt: number): number;
+}
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+export declare class CircuitBreaker {
+    readonly failureThreshold: number;
+    readonly recoveryTimeout: number;
+    readonly halfOpenMaxCalls: number;
+    private state;
+    private failures;
+    private lastFailureTime;
+    private halfOpenCalls;
+    constructor(failureThreshold?: number, recoveryTimeout?: number, halfOpenMaxCalls?: number);
+    canExecute(): boolean;
+    recordSuccess(): void;
+    recordFailure(): void;
+    getState(): CircuitState;
+    reset(): void;
+}
+/**
+ * Resolve template variables in a value.
+ * Supports {{variable}} and {{inputs.name}} syntax.
+ */
+export declare function resolveTemplates(value: unknown, context: ExecutionContext): unknown;
+/**
+ * Resolve a variable path from context.
+ * First checks inputs.*, then variables, then stepMetadata, then direct context properties.
+ * Exported to allow access from condition evaluation.
+ */
+export declare function resolveVariablePath(path: string, context: ExecutionContext): unknown;
+export declare class WorkflowEngine {
+    private config;
+    private retryPolicy;
+    private circuitBreakers;
+    private events;
+    private stateStore?;
+    private rollbackRegistry?;
+    private failoverConfig;
+    private healthTracker;
+    private failoverEvents;
+    constructor(config?: EngineConfig, events?: EngineEvents, stateStore?: StateStore);
+    /**
+     * Execute a workflow.
+     */
+    execute(workflow: Workflow, inputs: Record<string, unknown> | undefined, sdkRegistry: SDKRegistryLike, stepExecutor: StepExecutor): Promise<WorkflowResult>;
+    getFailoverHistory(): FailoverEvent[];
+    /**
+     * Execute a step with retry logic.
+     */
+    private executeStepWithRetry;
+    /**
+     * Execute a step with retry + failover support.
+     */
+    private executeStepWithFailover;
+    /**
+     * Execute a function with a timeout.
+     */
+    private executeWithTimeout;
+    /**
+     * Evaluate step conditions.
+     */
+    private evaluateConditions;
+    /**
+     * Evaluate a single condition.
+     * Supports: ==, !=, >, <, >=, <=
+     * Also supports nested property access (e.g., check_result.success)
+     * and step status checks (e.g., step_id.status == 'failed')
+     */
+    private evaluateCondition;
+    /**
+     * Resolve a condition value with support for nested properties.
+     * Handles direct variable references and nested paths.
+     */
+    private resolveConditionValue;
+    /**
+     * Parse a value from a condition string.
+     */
+    private parseValue;
+    /**
+     * Build the final workflow result.
+     */
+    private buildWorkflowResult;
+    /**
+     * Reset all circuit breakers.
+     */
+    resetCircuitBreakers(): void;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}

package/dist/engine.js

@@ -0,0 +1,514 @@
+/**
+ * Workflow Execution Engine for marktoflow v2.0
+ *
+ * Executes workflow steps with retry logic, variable resolution,
+ * and SDK invocation.
+ */
+import { StepStatus, WorkflowStatus, createExecutionContext, createStepResult, } from './models.js';
+import { DEFAULT_FAILOVER_CONFIG, AgentHealthTracker, FailoverReason, } from './failover.js';
+// ============================================================================
+// Retry Policy
+// ============================================================================
+export class RetryPolicy {
+    maxRetries;
+    baseDelay;
+    maxDelay;
+    exponentialBase;
+    jitter;
+    constructor(maxRetries = 3, baseDelay = 1000, maxDelay = 30000, exponentialBase = 2, jitter = 0.1) {
+        this.maxRetries = maxRetries;
+        this.baseDelay = baseDelay;
+        this.maxDelay = maxDelay;
+        this.exponentialBase = exponentialBase;
+        this.jitter = jitter;
+    }
+    /**
+     * Calculate delay for a given retry attempt.
+     */
+    getDelay(attempt) {
+        const exponentialDelay = this.baseDelay * Math.pow(this.exponentialBase, attempt);
+        const clampedDelay = Math.min(exponentialDelay, this.maxDelay);
+        // Add jitter
+        const jitterAmount = clampedDelay * this.jitter * (Math.random() * 2 - 1);
+        return Math.max(0, clampedDelay + jitterAmount);
+    }
+}
+export class CircuitBreaker {
+    failureThreshold;
+    recoveryTimeout;
+    halfOpenMaxCalls;
+    state = 'CLOSED';
+    failures = 0;
+    lastFailureTime = 0;
+    halfOpenCalls = 0;
+    constructor(failureThreshold = 5, recoveryTimeout = 30000, halfOpenMaxCalls = 3) {
+        this.failureThreshold = failureThreshold;
+        this.recoveryTimeout = recoveryTimeout;
+        this.halfOpenMaxCalls = halfOpenMaxCalls;
+    }
+    canExecute() {
+        if (this.state === 'CLOSED') {
+            return true;
+        }
+        if (this.state === 'OPEN') {
+            const timeSinceFailure = Date.now() - this.lastFailureTime;
+            if (timeSinceFailure >= this.recoveryTimeout) {
+                this.state = 'HALF_OPEN';
+                this.halfOpenCalls = 0;
+                return true;
+            }
+            return false;
+        }
+        // HALF_OPEN
+        return this.halfOpenCalls < this.halfOpenMaxCalls;
+    }
+    recordSuccess() {
+        this.failures = 0;
+        this.state = 'CLOSED';
+    }
+    recordFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.state === 'HALF_OPEN') {
+            this.state = 'OPEN';
+        }
+        else if (this.failures >= this.failureThreshold) {
+            this.state = 'OPEN';
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    reset() {
+        this.state = 'CLOSED';
+        this.failures = 0;
+        this.halfOpenCalls = 0;
+    }
+}
+// ============================================================================
+// Variable Resolution
+// ============================================================================
+/**
+ * Resolve template variables in a value.
+ * Supports {{variable}} and {{inputs.name}} syntax.
+ */
+export function resolveTemplates(value, context) {
+    if (typeof value === 'string') {
+        return value.replace(/\{\{([^}]+)\}\}/g, (_, varPath) => {
+            const path = varPath.trim();
+            const resolved = resolveVariablePath(path, context);
+            return resolved !== undefined ? String(resolved) : '';
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => resolveTemplates(v, context));
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = resolveTemplates(v, context);
+        }
+        return result;
+    }
+    return value;
+}
+/**
+ * Resolve a variable path from context.
+ * First checks inputs.*, then variables, then stepMetadata, then direct context properties.
+ * Exported to allow access from condition evaluation.
+ */
+export function resolveVariablePath(path, context) {
+    // Handle inputs.* prefix
+    if (path.startsWith('inputs.')) {
+        const inputPath = path.slice(7); // Remove 'inputs.'
+        return getNestedValue(context.inputs, inputPath);
+    }
+    // Check variables first (most common case)
+    const fromVars = getNestedValue(context.variables, path);
+    if (fromVars !== undefined) {
+        return fromVars;
+    }
+    // Check step metadata (for status checks like: step_id.status)
+    const fromStepMeta = getNestedValue(context.stepMetadata, path);
+    if (fromStepMeta !== undefined) {
+        return fromStepMeta;
+    }
+    // Fall back to direct context access
+    return getNestedValue(context, path);
+}
+/**
+ * Get a nested value from an object using dot notation.
+ */
+function getNestedValue(obj, path) {
+    if (obj === null || obj === undefined) {
+        return undefined;
+    }
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current === 'object') {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+export class WorkflowEngine {
+    config;
+    retryPolicy;
+    circuitBreakers = new Map();
+    events;
+    stateStore;
+    rollbackRegistry;
+    failoverConfig;
+    healthTracker;
+    failoverEvents = [];
+    constructor(config = {}, events = {}, stateStore) {
+        this.config = {
+            defaultTimeout: config.defaultTimeout ?? 60000,
+            maxRetries: config.maxRetries ?? 3,
+            retryBaseDelay: config.retryBaseDelay ?? 1000,
+            retryMaxDelay: config.retryMaxDelay ?? 30000,
+        };
+        this.retryPolicy = new RetryPolicy(this.config.maxRetries, this.config.retryBaseDelay, this.config.retryMaxDelay);
+        this.events = events;
+        this.stateStore = stateStore;
+        this.rollbackRegistry = config.rollbackRegistry;
+        this.failoverConfig = { ...DEFAULT_FAILOVER_CONFIG, ...(config.failoverConfig ?? {}) };
+        this.healthTracker = config.healthTracker ?? new AgentHealthTracker();
+    }
+    /**
+     * Execute a workflow.
+     */
+    async execute(workflow, inputs = {}, sdkRegistry, stepExecutor) {
+        const context = createExecutionContext(workflow, inputs);
+        const stepResults = [];
+        const startedAt = new Date();
+        context.status = WorkflowStatus.RUNNING;
+        this.events.onWorkflowStart?.(workflow, context);
+        if (this.stateStore) {
+            this.stateStore.createExecution({
+                runId: context.runId,
+                workflowId: workflow.metadata.id,
+                workflowPath: 'unknown',
+                status: WorkflowStatus.RUNNING,
+                startedAt: startedAt,
+                completedAt: null,
+                currentStep: 0,
+                totalSteps: workflow.steps.length,
+                inputs: inputs,
+                outputs: null,
+                error: null,
+                metadata: null,
+            });
+        }
+        try {
+            for (let i = 0; i < workflow.steps.length; i++) {
+                const step = workflow.steps[i];
+                context.currentStepIndex = i;
+                // Check conditions
+                if (step.conditions && !this.evaluateConditions(step.conditions, context)) {
+                    const skipResult = createStepResult(step.id, StepStatus.SKIPPED, null, new Date());
+                    stepResults.push(skipResult);
+                    continue;
+                }
+                // Execute step with retry
+                const result = await this.executeStepWithFailover(step, context, sdkRegistry, stepExecutor);
+                stepResults.push(result);
+                // Store step metadata (status, error, etc.) in separate field for condition evaluation
+                // This allows conditions like: step_id.status == 'failed'
+                context.stepMetadata[step.id] = {
+                    status: result.status.toLowerCase(),
+                    retryCount: result.retryCount,
+                    ...(result.error ? { error: result.error } : {}),
+                };
+                // Store output variable
+                if (step.outputVariable && result.status === StepStatus.COMPLETED) {
+                    context.variables[step.outputVariable] = result.output;
+                }
+                // Handle failure
+                if (result.status === StepStatus.FAILED) {
+                    const errorAction = step.errorHandling?.action ?? 'stop';
+                    if (errorAction === 'stop') {
+                        context.status = WorkflowStatus.FAILED;
+                        const workflowError = result.error || `Step ${step.id} failed`;
+                        const workflowResult = this.buildWorkflowResult(workflow, context, stepResults, startedAt, workflowError);
+                        this.events.onWorkflowComplete?.(workflow, workflowResult);
+                        return workflowResult;
+                    }
+                    // 'continue' - keep going
+                    if (errorAction === 'rollback') {
+                        if (this.rollbackRegistry) {
+                            await this.rollbackRegistry.rollbackAllAsync({
+                                context,
+                                inputs: context.inputs,
+                                variables: context.variables,
+                            });
+                        }
+                        context.status = WorkflowStatus.FAILED;
+                        const workflowError = result.error || `Step ${step.id} failed`;
+                        const workflowResult = this.buildWorkflowResult(workflow, context, stepResults, startedAt, workflowError);
+                        this.events.onWorkflowComplete?.(workflow, workflowResult);
+                        return workflowResult;
+                    }
+                }
+            }
+            // Determine final status
+            context.status = WorkflowStatus.COMPLETED;
+        }
+        catch (error) {
+            context.status = WorkflowStatus.FAILED;
+            if (this.stateStore) {
+                this.stateStore.updateExecution(context.runId, {
+                    status: WorkflowStatus.FAILED,
+                    completedAt: new Date(),
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            const workflowResult = this.buildWorkflowResult(workflow, context, stepResults, startedAt, error instanceof Error ? error.message : String(error));
+            this.events.onWorkflowComplete?.(workflow, workflowResult);
+            return workflowResult;
+        }
+        const workflowResult = this.buildWorkflowResult(workflow, context, stepResults, startedAt);
+        if (this.stateStore) {
+            this.stateStore.updateExecution(context.runId, {
+                status: context.status,
+                completedAt: new Date(),
+                outputs: context.variables,
+            });
+        }
+        this.events.onWorkflowComplete?.(workflow, workflowResult);
+        return workflowResult;
+    }
+    getFailoverHistory() {
+        return [...this.failoverEvents];
+    }
+    /**
+     * Execute a step with retry logic.
+     */
+    async executeStepWithRetry(step, context, sdkRegistry, stepExecutor) {
+        const maxRetries = step.errorHandling?.maxRetries ?? this.config.maxRetries;
+        const startedAt = new Date();
+        let lastError;
+        // Get or create circuit breaker for this step's action
+        const [serviceName] = step.action.split('.');
+        let circuitBreaker = this.circuitBreakers.get(serviceName);
+        if (!circuitBreaker) {
+            circuitBreaker = new CircuitBreaker();
+            this.circuitBreakers.set(serviceName, circuitBreaker);
+        }
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            // Check circuit breaker
+            if (!circuitBreaker.canExecute()) {
+                return createStepResult(step.id, StepStatus.FAILED, null, startedAt, attempt, `Circuit breaker open for service: ${serviceName}`);
+            }
+            this.events.onStepStart?.(step, context);
+            try {
+                // Resolve templates in inputs
+                const resolvedInputs = resolveTemplates(step.inputs, context);
+                const stepWithResolvedInputs = { ...step, inputs: resolvedInputs };
+                // Execute step
+                const output = await this.executeWithTimeout(() => stepExecutor(stepWithResolvedInputs, context, sdkRegistry), step.timeout ?? this.config.defaultTimeout);
+                circuitBreaker.recordSuccess();
+                const result = createStepResult(step.id, StepStatus.COMPLETED, output, startedAt, attempt);
+                this.events.onStepComplete?.(step, result);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                circuitBreaker.recordFailure();
+                this.events.onStepError?.(step, lastError, attempt);
+                // Wait before retry (unless last attempt)
+                if (attempt < maxRetries) {
+                    const delay = this.retryPolicy.getDelay(attempt);
+                    await sleep(delay);
+                }
+            }
+        }
+        // All retries exhausted
+        const result = createStepResult(step.id, StepStatus.FAILED, null, startedAt, maxRetries, lastError?.message);
+        this.events.onStepComplete?.(step, result);
+        return result;
+    }
+    /**
+     * Execute a step with retry + failover support.
+     */
+    async executeStepWithFailover(step, context, sdkRegistry, stepExecutor) {
+        const primaryResult = await this.executeStepWithRetry(step, context, sdkRegistry, stepExecutor);
+        const [primaryTool, ...methodParts] = step.action.split('.');
+        const method = methodParts.join('.');
+        if (primaryResult.status === StepStatus.COMPLETED) {
+            this.healthTracker.markHealthy(primaryTool);
+            return primaryResult;
+        }
+        const errorMessage = primaryResult.error ?? '';
+        const isTimeout = errorMessage.includes('timed out');
+        if (isTimeout && !this.failoverConfig.failoverOnTimeout) {
+            this.healthTracker.markUnhealthy(primaryTool, errorMessage);
+            return primaryResult;
+        }
+        if (!isTimeout && !this.failoverConfig.failoverOnStepFailure) {
+            this.healthTracker.markUnhealthy(primaryTool, errorMessage);
+            return primaryResult;
+        }
+        if (!method || this.failoverConfig.fallbackAgents.length === 0) {
+            this.healthTracker.markUnhealthy(primaryTool, errorMessage);
+            return primaryResult;
+        }
+        let attempts = 0;
+        for (const fallbackTool of this.failoverConfig.fallbackAgents) {
+            if (fallbackTool === primaryTool)
+                continue;
+            if (attempts >= this.failoverConfig.maxFailoverAttempts)
+                break;
+            const fallbackStep = { ...step, action: `${fallbackTool}.${method}` };
+            const result = await this.executeStepWithRetry(fallbackStep, context, sdkRegistry, stepExecutor);
+            this.failoverEvents.push({
+                timestamp: new Date(),
+                fromAgent: primaryTool,
+                toAgent: fallbackTool,
+                reason: isTimeout ? FailoverReason.TIMEOUT : FailoverReason.STEP_EXECUTION_FAILED,
+                stepIndex: context.currentStepIndex,
+                error: errorMessage || undefined,
+            });
+            attempts += 1;
+            if (result.status === StepStatus.COMPLETED) {
+                this.healthTracker.markHealthy(fallbackTool);
+                return result;
+            }
+        }
+        this.healthTracker.markUnhealthy(primaryTool, errorMessage);
+        return primaryResult;
+    }
+    /**
+     * Execute a function with a timeout.
+     */
+    async executeWithTimeout(fn, timeoutMs) {
+        return Promise.race([
+            fn(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Step timed out after ${timeoutMs}ms`)), timeoutMs)),
+        ]);
+    }
+    /**
+     * Evaluate step conditions.
+     */
+    evaluateConditions(conditions, context) {
+        for (const condition of conditions) {
+            if (!this.evaluateCondition(condition, context)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Evaluate a single condition.
+     * Supports: ==, !=, >, <, >=, <=
+     * Also supports nested property access (e.g., check_result.success)
+     * and step status checks (e.g., step_id.status == 'failed')
+     */
+    evaluateCondition(condition, context) {
+        // Simple expression parsing
+        const operators = ['==', '!=', '>=', '<=', '>', '<'];
+        let operator;
+        let parts = [];
+        for (const op of operators) {
+            if (condition.includes(op)) {
+                operator = op;
+                parts = condition.split(op).map((s) => s.trim());
+                break;
+            }
+        }
+        if (!operator || parts.length !== 2) {
+            // Treat as boolean variable reference with nested property support
+            const value = this.resolveConditionValue(condition, context);
+            return Boolean(value);
+        }
+        const left = this.resolveConditionValue(parts[0], context);
+        const right = this.parseValue(parts[1]);
+        switch (operator) {
+            case '==':
+                return left == right;
+            case '!=':
+                return left != right;
+            case '>':
+                return Number(left) > Number(right);
+            case '<':
+                return Number(left) < Number(right);
+            case '>=':
+                return Number(left) >= Number(right);
+            case '<=':
+                return Number(left) <= Number(right);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Resolve a condition value with support for nested properties.
+     * Handles direct variable references and nested paths.
+     */
+    resolveConditionValue(path, context) {
+        // Try to resolve the path directly from variables
+        const resolved = resolveVariablePath(path, context);
+        // Return the resolved value directly
+        return resolved;
+    }
+    /**
+     * Parse a value from a condition string.
+     */
+    parseValue(value) {
+        // Remove quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            return value.slice(1, -1);
+        }
+        // Numbers
+        if (!isNaN(Number(value))) {
+            return Number(value);
+        }
+        // Booleans
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        if (value === 'null')
+            return null;
+        return value;
+    }
+    /**
+     * Build the final workflow result.
+     */
+    buildWorkflowResult(workflow, context, stepResults, startedAt, error) {
+        const completedAt = new Date();
+        return {
+            workflowId: workflow.metadata.id,
+            runId: context.runId,
+            status: context.status,
+            stepResults,
+            output: context.variables,
+            error,
+            startedAt,
+            completedAt,
+            duration: completedAt.getTime() - startedAt.getTime(),
+        };
+    }
+    /**
+     * Reset all circuit breakers.
+     */
+    resetCircuitBreakers() {
+        for (const breaker of this.circuitBreakers.values()) {
+            breaker.reset();
+        }
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=engine.js.map