@exaudeus/workrail 0.8.6 → 0.10.0

package/dist/application/services/workflow-service.d.ts

@@ -1,47 +1,49 @@
+import type { ConditionContext } from '../../utils/condition-evaluator';
+import type { Workflow, WorkflowSummary } from '../../types/workflow';
+import { ValidationEngine } from './validation-engine';
+import { WorkflowCompiler } from './workflow-compiler';
+import { WorkflowInterpreter, NextStep } from './workflow-interpreter';
+import type { ExecutionState } from '../../domain/execution/state';
+import type { WorkflowEvent } from '../../domain/execution/event';
+import type { DomainError } from '../../domain/execution/error';
+import type { Result } from 'neverthrow';
 export interface WorkflowService {
-    listWorkflowSummaries(): Promise<import('../../types/mcp-types').WorkflowSummary[]>;
-    getWorkflowById(id: string): Promise<import('../../types/mcp-types').Workflow | null>;
-    getNextStep(workflowId: string, completedSteps: string[], context?: ConditionContext): Promise<{
-        step: import('../../types/mcp-types').WorkflowStep | null;
-        guidance: import('../../types/mcp-types').WorkflowGuidance;
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
+    getWorkflowById(id: string): Promise<Workflow | null>;
+    getNextStep(workflowId: string, state: ExecutionState, event?: WorkflowEvent, context?: ConditionContext): Promise<Result<{
+        state: ExecutionState;
+        next: NextStep | null;
         isComplete: boolean;
-        context?: ConditionContext;
-    }>;
+    }, DomainError>>;
     validateStepOutput(workflowId: string, stepId: string, output: string): Promise<{
         valid: boolean;
-        issues: string[];
-        suggestions: string[];
+        issues: readonly string[];
+        suggestions: readonly string[];
     }>;
 }
-import { Workflow, WorkflowSummary, WorkflowStep, WorkflowGuidance } from '../../types/mcp-types';
-import { IWorkflowStorage } from '../../types/storage';
-import { ConditionContext } from '../../utils/condition-evaluator';
-import { ValidationEngine } from './validation-engine';
-import { EnhancedContext } from '../../types/workflow-types';
-import { ILoopContextOptimizer } from '../../types/loop-context-optimizer';
 export declare class DefaultWorkflowService implements WorkflowService {
     private readonly storage;
     private readonly validationEngine;
-    private readonly loopContextOptimizer?;
-    private loopStepResolver;
-    constructor(storage?: IWorkflowStorage, validationEngine?: ValidationEngine, loopContextOptimizer?: ILoopContextOptimizer | undefined);
-    listWorkflowSummaries(): Promise<WorkflowSummary[]>;
+    private readonly compiler;
+    private readonly interpreter;
+    private readonly logger;
+    private readonly compiledCache;
+    private readonly COMPILED_CACHE_MAX;
+    constructor(storage: import('../../types/storage').IWorkflowReader, validationEngine: ValidationEngine, compiler: WorkflowCompiler, interpreter: WorkflowInterpreter);
+    listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    getNextStep(workflowId: string, completedSteps: string[], context?: ConditionContext): Promise<{
-        step: WorkflowStep | null;
-        guidance: WorkflowGuidance;
+    getNextStep(workflowId: string, state: ExecutionState, event?: WorkflowEvent, context?: ConditionContext): Promise<Result<{
+        state: ExecutionState;
+        next: NextStep | null;
         isComplete: boolean;
-        context?: ConditionContext;
-    }>;
-    private buildStepPrompt;
-    private collectConditionVars;
-    private collectEqualsValues;
-    private findLoopStepById;
+    }, DomainError>>;
     validateStepOutput(workflowId: string, stepId: string, output: string): Promise<{
         valid: boolean;
-        issues: string[];
-        suggestions: string[];
+        issues: readonly string[];
+        suggestions: readonly string[];
     }>;
-    updateContextForStepCompletion(workflowId: string, stepId: string, context: ConditionContext): Promise<EnhancedContext>;
+    private getOrCompile;
+    __debugCompiledCacheSize(): number;
+    __debugPrimeCompiledWorkflow(id: string): void;
+    private evictCompiledCacheIfNeeded;
 }
-export declare const defaultWorkflowService: WorkflowService;

package/dist/application/services/workflow-service.js

@@ -1,21 +1,35 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultWorkflowService = exports.DefaultWorkflowService = void 0;
-const storage_1 = require("../../infrastructure/storage");
-const error_handler_1 = require("../../core/error-handler");
-const condition_evaluator_1 = require("../../utils/condition-evaluator");
+exports.DefaultWorkflowService = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_js_1 = require("../../di/tokens.js");
 const validation_engine_1 = require("./validation-engine");
-const workflow_types_1 = require("../../types/workflow-types");
-const loop_execution_context_1 = require("./loop-execution-context");
-const loop_step_resolver_1 = require("./loop-step-resolver");
-const context_size_1 = require("../../utils/context-size");
-const context_optimizer_1 = require("./context-optimizer");
-class DefaultWorkflowService {
-    constructor(storage = (0, storage_1.createDefaultWorkflowStorage)(), validationEngine = new validation_engine_1.ValidationEngine(), loopContextOptimizer) {
+const workflow_compiler_1 = require("./workflow-compiler");
+const workflow_interpreter_1 = require("./workflow-interpreter");
+const error_1 = require("../../domain/execution/error");
+const neverthrow_1 = require("neverthrow");
+const logger_1 = require("../../utils/logger");
+let DefaultWorkflowService = class DefaultWorkflowService {
+    constructor(storage, validationEngine, compiler, interpreter) {
         this.storage = storage;
         this.validationEngine = validationEngine;
-        this.loopContextOptimizer = loopContextOptimizer;
-        this.loopStepResolver = new loop_step_resolver_1.LoopStepResolver();
+        this.compiler = compiler;
+        this.interpreter = interpreter;
+        this.logger = (0, logger_1.createLogger)('WorkflowService');
+        this.compiledCache = new Map();
+        this.COMPILED_CACHE_MAX = 1000;
     }
     async listWorkflowSummaries() {
         return this.storage.listWorkflowSummaries();
@@ -23,428 +37,82 @@ class DefaultWorkflowService {
     async getWorkflowById(id) {
         return this.storage.getWorkflowById(id);
     }
-    async getNextStep(workflowId, completedSteps, context = {}) {
-        const sizeCheck = (0, context_size_1.checkContextSize)(context);
-        if (sizeCheck.isError) {
-            throw new Error(`Context size (${Math.round(sizeCheck.sizeBytes / 1024)}KB) exceeds maximum allowed size (256KB)`);
-        }
-        const checkedContext = sizeCheck.context;
+    async getNextStep(workflowId, state, event, context = {}) {
         const workflow = await this.storage.getWorkflowById(workflowId);
-        if (!workflow) {
-            throw new error_handler_1.WorkflowNotFoundError(workflowId);
-        }
-        const validationResult = this.validationEngine.validateWorkflow(workflow);
-        if (!validationResult.valid) {
-            throw new Error(`Invalid workflow structure: ${validationResult.issues.join('; ')}`);
-        }
-        const completed = [...(completedSteps || [])];
-        const enhancedContext = checkedContext;
-        const loopBodySteps = new Set();
-        const bodyStepToLoop = new Map();
-        for (const step of workflow.steps) {
-            if ((0, workflow_types_1.isLoopStep)(step)) {
-                const loopStep = step;
-                if (typeof loopStep.body === 'string') {
-                    loopBodySteps.add(loopStep.body);
-                    bodyStepToLoop.set(loopStep.body, loopStep);
-                }
-                else if (Array.isArray(loopStep.body)) {
-                    loopStep.body.forEach(bodyStep => {
-                        loopBodySteps.add(bodyStep.id);
-                        bodyStepToLoop.set(bodyStep.id, loopStep);
-                    });
-                }
-            }
-        }
-        if (!enhancedContext._currentLoop) {
-            const completedLoopBodySteps = completed.filter(stepId => loopBodySteps.has(stepId));
-            if (completedLoopBodySteps.length > 0) {
-                const loopStep = bodyStepToLoop.get(completedLoopBodySteps[0]);
-                if (loopStep && !completed.includes(loopStep.id)) {
-                    enhancedContext._currentLoop = {
-                        loopId: loopStep.id,
-                        loopStep: loopStep
-                    };
-                    if (!enhancedContext._loopState || !enhancedContext._loopState[loopStep.id]) {
-                        const resolvedBody = this.loopStepResolver.resolveLoopBody(workflow, loopStep.body, loopStep.id);
-                        let completedIterations = 0;
-                        if (Array.isArray(resolvedBody)) {
-                            const hasConditionalSteps = resolvedBody.some(step => step.runCondition);
-                            if (hasConditionalSteps) {
-                                completedIterations = completedLoopBodySteps.length;
-                            }
-                            else {
-                                completedIterations = 0;
-                            }
-                        }
-                        else {
-                            completedIterations = completedLoopBodySteps.length;
-                        }
-                        if (!enhancedContext._loopState) {
-                            enhancedContext._loopState = {};
-                        }
-                        enhancedContext._loopState[loopStep.id] = {
-                            iteration: completedIterations,
-                            started: Date.now(),
-                            warnings: []
-                        };
-                    }
-                }
-            }
-        }
-        if (enhancedContext._currentLoop) {
-            const { loopId, loopStep } = enhancedContext._currentLoop;
-            const loopContext = new loop_execution_context_1.LoopExecutionContext(loopId, loopStep.loop, enhancedContext._loopState?.[loopId]);
-            const bodyStep = this.loopStepResolver.resolveLoopBody(workflow, loopStep.body, loopStep.id);
-            let bodyIsCompleted;
-            if (Array.isArray(bodyStep)) {
-                const loopEnhancedContext = loopContext.injectVariables(enhancedContext, false);
-                const eligibleSteps = bodyStep.filter(step => {
-                    if (!step.runCondition) {
-                        return true;
-                    }
-                    return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, loopEnhancedContext);
-                });
-                bodyIsCompleted = eligibleSteps.length === 0 || eligibleSteps.every(step => completed.includes(step.id));
-            }
-            else {
-                bodyIsCompleted = completed.includes(bodyStep.id);
-            }
-            if (bodyIsCompleted) {
-                loopContext.incrementIteration();
-                if (!enhancedContext._loopState) {
-                    enhancedContext._loopState = {};
-                }
-                enhancedContext._loopState[loopId] = loopContext.getCurrentState();
-                if (Array.isArray(bodyStep)) {
-                    bodyStep.forEach(step => {
-                        const index = completed.indexOf(step.id);
-                        if (index > -1) {
-                            completed.splice(index, 1);
-                        }
-                    });
-                }
-                else {
-                    const index = completed.indexOf(bodyStep.id);
-                    if (index > -1) {
-                        completed.splice(index, 1);
-                    }
-                }
-                if (!loopContext.shouldContinue(context)) {
-                    completed.push(loopId);
-                    delete enhancedContext._currentLoop;
-                    const nextStep = await this.getNextStep(workflow.id, completed, enhancedContext);
-                    return nextStep;
-                }
-            }
-            if (loopContext.shouldContinue(context)) {
-                if (!Array.isArray(bodyStep)) {
-                    const isFirst = loopContext.isFirstIteration();
-                    if (isFirst && loopContext.isEmpty(context)) {
-                        const skipContext = context_optimizer_1.ContextOptimizer.createEnhancedContext(context, completed);
-                        delete skipContext._currentLoop;
-                        const nextStep = await this.getNextStep(workflow.id, completed, skipContext);
-                        return nextStep;
-                    }
-                    const useMinimal = !isFirst && !!this.loopContextOptimizer;
-                    const loopEnhancedContext = loopContext.injectVariables(context, useMinimal);
-                    const optimizedContext = useMinimal && this.loopContextOptimizer
-                        ? this.loopContextOptimizer.stripLoopMetadata(loopEnhancedContext)
-                        : loopEnhancedContext;
-                    const loopSizeCheck = (0, context_size_1.checkContextSize)(optimizedContext);
-                    if (loopSizeCheck.isError) {
-                        throw new Error(`Context size (${Math.round(loopSizeCheck.sizeBytes / 1024)}KB) exceeds maximum allowed size (256KB) during loop execution`);
-                    }
-                    return {
-                        step: bodyStep,
-                        guidance: {
-                            prompt: this.buildStepPrompt(bodyStep, loopContext, useMinimal)
-                        },
-                        isComplete: false,
-                        context: loopSizeCheck.context
-                    };
-                }
-                else {
-                    const isFirst = loopContext.isFirstIteration();
-                    if (isFirst && loopContext.isEmpty(context)) {
-                        const skipContext = context_optimizer_1.ContextOptimizer.createEnhancedContext(context, completed);
-                        delete skipContext._currentLoop;
-                        const nextStep = await this.getNextStep(workflow.id, completed, skipContext);
-                        return nextStep;
-                    }
-                    const useMinimal = !isFirst && !!this.loopContextOptimizer;
-                    const loopEnhancedContext = loopContext.injectVariables(context, useMinimal);
-                    const uncompletedBodyStep = bodyStep.find(step => {
-                        if (completed.includes(step.id)) {
-                            return false;
-                        }
-                        if (step.runCondition) {
-                            return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, loopEnhancedContext);
-                        }
-                        return true;
-                    });
-                    if (uncompletedBodyStep) {
-                        const optimizedContext = useMinimal && this.loopContextOptimizer
-                            ? this.loopContextOptimizer.stripLoopMetadata(loopEnhancedContext)
-                            : loopEnhancedContext;
-                        const loopSizeCheck = (0, context_size_1.checkContextSize)(optimizedContext);
-                        if (loopSizeCheck.isError) {
-                            throw new Error(`Context size (${Math.round(loopSizeCheck.sizeBytes / 1024)}KB) exceeds maximum allowed size (256KB) during loop execution`);
-                        }
-                        return {
-                            step: uncompletedBodyStep,
-                            guidance: {
-                                prompt: this.buildStepPrompt(uncompletedBodyStep, loopContext, useMinimal)
-                            },
-                            isComplete: false,
-                            context: loopSizeCheck.context
-                        };
-                    }
-                    else {
-                        loopContext.incrementIteration();
-                        if (!enhancedContext._loopState) {
-                            enhancedContext._loopState = {};
-                        }
-                        enhancedContext._loopState[loopId] = loopContext.getCurrentState();
-                        bodyStep.forEach(step => {
-                            const index = completed.indexOf(step.id);
-                            if (index > -1) {
-                                completed.splice(index, 1);
-                            }
-                        });
-                        return this.getNextStep(workflowId, completed, enhancedContext);
-                    }
-                }
-            }
-            else {
-                completed.push(loopId);
-                delete enhancedContext._currentLoop;
-            }
-        }
-        const nextStep = workflow.steps.find((step) => {
-            if (completed.includes(step.id)) {
-                return false;
-            }
-            if (loopBodySteps.has(step.id)) {
-                if (!enhancedContext._currentLoop) {
-                    return false;
-                }
-                const currentLoopBody = enhancedContext._currentLoop.loopStep.body;
-                if (typeof currentLoopBody === 'string') {
-                    return currentLoopBody === step.id;
-                }
-                else if (Array.isArray(currentLoopBody)) {
-                    return currentLoopBody.some(bodyStep => bodyStep.id === step.id);
-                }
-                return false;
-            }
-            if (step.runCondition) {
-                return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, context);
-            }
-            return true;
-        }) || null;
-        if (nextStep && (0, workflow_types_1.isLoopStep)(nextStep)) {
-            const loopStep = nextStep;
-            const loopContext = new loop_execution_context_1.LoopExecutionContext(nextStep.id, loopStep.loop, enhancedContext._loopState?.[nextStep.id]);
-            if (loopStep.loop.type === 'forEach') {
-                loopContext.initializeForEach(context);
-            }
-            if (!loopContext.shouldContinue(context)) {
-                completed.push(nextStep.id);
-                const loopStateData = loopContext.getCurrentState();
-                let skipContext = context_optimizer_1.ContextOptimizer.mergeLoopState(context, nextStep.id, loopStateData);
-                if (loopStateData.warnings && loopStateData.warnings.length > 0) {
-                    skipContext = context_optimizer_1.ContextOptimizer.addWarnings(skipContext, 'loops', nextStep.id, loopStateData.warnings);
-                }
-                return this.getNextStep(workflowId, completed, skipContext);
-            }
-            let newContext = context_optimizer_1.ContextOptimizer.createEnhancedContext(context, {
-                _currentLoop: {
-                    loopId: nextStep.id,
-                    loopStep: loopStep
-                }
-            });
-            newContext = context_optimizer_1.ContextOptimizer.mergeLoopState(newContext, nextStep.id, loopContext.getCurrentState());
-            const loopStartSizeCheck = (0, context_size_1.checkContextSize)(newContext);
-            if (loopStartSizeCheck.isError) {
-                throw new Error(`Context size (${Math.round(loopStartSizeCheck.sizeBytes / 1024)}KB) exceeds maximum allowed size (256KB) when starting loop`);
-            }
-            return this.getNextStep(workflowId, completedSteps, loopStartSizeCheck.context);
-        }
-        if (!nextStep) {
-            const remainingConditionalSteps = workflow.steps.filter((step) => {
-                if (completed.includes(step.id))
-                    return false;
-                if (loopBodySteps.has(step.id))
-                    return false;
-                return !!step.runCondition;
-            });
-            if (remainingConditionalSteps.length > 0) {
-                const requiredVars = new Set();
-                const allowedValues = {};
-                for (const step of remainingConditionalSteps) {
-                    const condition = step.runCondition;
-                    this.collectConditionVars(condition, requiredVars);
-                    this.collectEqualsValues(condition, allowedValues);
-                }
-                const issues = [];
-                for (const variableName of requiredVars) {
-                    const currentValue = enhancedContext[variableName];
-                    const allowed = allowedValues[variableName]
-                        ? Array.from(allowedValues[variableName])
-                        : [];
-                    if (currentValue === undefined || currentValue === null || currentValue === '') {
-                        if (allowed.length > 0) {
-                            issues.push(`Set '${variableName}' to one of: ${allowed.map(v => `'${v}'`).join(', ')}`);
-                        }
-                        else {
-                            issues.push(`Provide a value for '${variableName}'`);
-                        }
-                    }
-                    else if (allowed.length > 0) {
-                        const matchesExactly = allowed.some(v => v === String(currentValue));
-                        const matchesCaseInsensitive = allowed.some(v => v.toLowerCase() === String(currentValue).toLowerCase());
-                        if (!matchesExactly) {
-                            if (matchesCaseInsensitive) {
-                                issues.push(`Normalize casing for '${variableName}': use one of ${allowed.map(v => `'${v}'`).join(', ')} (current '${currentValue}')`);
-                            }
-                            else {
-                                issues.push(`Adjust '${variableName}' to one of: ${allowed.map(v => `'${v}'`).join(', ')} (current '${currentValue}')`);
-                            }
-                        }
-                    }
-                }
-                if (issues.length > 0) {
-                    return {
-                        step: null,
-                        guidance: {
-                            prompt: `No eligible step due to unmet conditions. Please update context:\n- ${issues.join('\n- ')}`
-                        },
-                        isComplete: false,
-                        context: enhancedContext
-                    };
-                }
-            }
-        }
-        const isComplete = !nextStep;
-        let finalPrompt = 'Workflow complete.';
-        if (nextStep) {
-            finalPrompt = this.buildStepPrompt(nextStep);
-        }
-        return {
-            step: nextStep,
-            guidance: {
-                prompt: finalPrompt
-            },
-            isComplete,
-            context: enhancedContext
-        };
-    }
-    buildStepPrompt(step, loopContext, useMinimal = false) {
-        let stepGuidance = '';
-        if (step.guidance && step.guidance.length > 0) {
-            const guidanceHeader = '## Step Guidance';
-            const guidanceList = step.guidance.map((g) => `- ${g}`).join('\n');
-            stepGuidance = `${guidanceHeader}\n${guidanceList}\n\n`;
-        }
-        let finalPrompt = `${stepGuidance}${step.prompt}`;
-        if (step.agentRole) {
-            finalPrompt = `## Agent Role Instructions\n${step.agentRole}\n\n${finalPrompt}`;
-        }
-        if (loopContext) {
-            const state = loopContext.getCurrentState();
-            if (useMinimal && this.loopContextOptimizer) {
-                finalPrompt += `\n\n## Loop Context\n- Iteration: ${state.iteration + 1}`;
-                if (!loopContext.isFirstIteration()) {
-                    finalPrompt += '\n\n_Note: Refer to the phase overview provided in the first iteration for overall context._';
-                }
-            }
-            else {
-                finalPrompt += `\n\n## Loop Context\n- Iteration: ${state.iteration + 1}`;
-                if (state.items) {
-                    finalPrompt += `\n- Total Items: ${state.items.length}`;
-                    finalPrompt += `\n- Current Index: ${state.index}`;
-                }
-            }
-        }
-        return finalPrompt;
-    }
-    collectConditionVars(condition, sink) {
-        if (!condition || typeof condition !== 'object')
-            return;
-        if (typeof condition.var === 'string' && condition.var.length > 0) {
-            sink.add(condition.var);
-        }
-        if (Array.isArray(condition.and)) {
-            for (const sub of condition.and)
-                this.collectConditionVars(sub, sink);
-        }
-        if (Array.isArray(condition.or)) {
-            for (const sub of condition.or)
-                this.collectConditionVars(sub, sink);
-        }
-        if (condition.not)
-            this.collectConditionVars(condition.not, sink);
-    }
-    collectEqualsValues(condition, sink) {
-        if (!condition || typeof condition !== 'object')
-            return;
-        if (typeof condition.var === 'string' && Object.prototype.hasOwnProperty.call(condition, 'equals')) {
-            const variableName = condition.var;
-            const value = condition.equals;
-            if (value !== undefined && value !== null) {
-                if (!sink[variableName])
-                    sink[variableName] = new Set();
-                sink[variableName].add(String(value));
-            }
-        }
-        if (Array.isArray(condition.and)) {
-            for (const sub of condition.and)
-                this.collectEqualsValues(sub, sink);
-        }
-        if (Array.isArray(condition.or)) {
-            for (const sub of condition.or)
-                this.collectEqualsValues(sub, sink);
-        }
-        if (condition.not)
-            this.collectEqualsValues(condition.not, sink);
-    }
-    findLoopStepById(workflow, stepId) {
-        const step = workflow.steps.find(s => s.id === stepId);
-        return step && (0, workflow_types_1.isLoopStep)(step) ? step : null;
+        if (!workflow)
+            return (0, neverthrow_1.err)(error_1.Err.workflowNotFound(workflowId));
+        const compiled = this.getOrCompile(workflowId, workflow);
+        if (compiled.isErr())
+            return (0, neverthrow_1.err)(compiled.error);
+        const advancedState = event ? this.interpreter.applyEvent(state, event) : (0, neverthrow_1.ok)(state);
+        if (advancedState.isErr())
+            return (0, neverthrow_1.err)(advancedState.error);
+        const next = this.interpreter.next(compiled.value, advancedState.value, context);
+        if (next.isErr())
+            return (0, neverthrow_1.err)(next.error);
+        return (0, neverthrow_1.ok)({
+            state: next.value.state,
+            next: next.value.next,
+            isComplete: next.value.isComplete,
+        });
     }
     async validateStepOutput(workflowId, stepId, output) {
         const workflow = await this.storage.getWorkflowById(workflowId);
         if (!workflow) {
-            throw new error_handler_1.WorkflowNotFoundError(workflowId);
+            return { valid: false, issues: [`Workflow '${workflowId}' not found`], suggestions: [] };
         }
-        const step = workflow.steps.find((s) => s.id === stepId);
+        const step = workflow.definition.steps.find((s) => s.id === stepId);
         if (!step) {
-            throw new error_handler_1.StepNotFoundError(stepId, workflowId);
+            return { valid: false, issues: [`Step '${stepId}' not found in workflow '${workflowId}'`], suggestions: [] };
         }
-        const criteria = step.validationCriteria || [];
+        const criteria = step.validationCriteria;
+        if (!criteria)
+            return { valid: true, issues: [], suggestions: [] };
         return this.validationEngine.validate(output, criteria);
     }
-    async updateContextForStepCompletion(workflowId, stepId, context) {
-        let enhancedContext = context;
-        if (enhancedContext._currentLoop) {
-            const { loopId, loopStep } = enhancedContext._currentLoop;
-            const workflow = await this.storage.getWorkflowById(workflowId);
-            if (workflow) {
-                const bodyStep = this.loopStepResolver.resolveLoopBody(workflow, loopStep.body, loopStep.id);
-                if (!Array.isArray(bodyStep) && bodyStep.id === stepId) {
-                    const loopContext = new loop_execution_context_1.LoopExecutionContext(loopId, loopStep.loop, enhancedContext._loopState?.[loopId]);
-                    loopContext.incrementIteration();
-                    enhancedContext = context_optimizer_1.ContextOptimizer.mergeLoopState(enhancedContext, loopId, loopContext.getCurrentState());
-                }
-            }
-        }
-        const sizeCheck = (0, context_size_1.checkContextSize)(enhancedContext);
-        if (sizeCheck.isError) {
-            throw new Error(`Context size (${Math.round(sizeCheck.sizeBytes / 1024)}KB) exceeds maximum allowed size (256KB) after step completion`);
+    getOrCompile(workflowId, workflow) {
+        const cached = this.compiledCache.get(workflowId);
+        if (cached)
+            return (0, neverthrow_1.ok)(cached);
+        const validation = this.validationEngine.validateWorkflow(workflow);
+        if (!validation.valid) {
+            return (0, neverthrow_1.err)(error_1.Err.invalidState(`Invalid workflow structure: ${validation.issues.join('; ')}`));
+        }
+        const compiled = this.compiler.compile(workflow);
+        if (compiled.isErr())
+            return (0, neverthrow_1.err)(compiled.error);
+        this.compiledCache.set(workflowId, compiled.value);
+        this.evictCompiledCacheIfNeeded();
+        return (0, neverthrow_1.ok)(compiled.value);
+    }
+    __debugCompiledCacheSize() {
+        return this.compiledCache.size;
+    }
+    __debugPrimeCompiledWorkflow(id) {
+        if (this.compiledCache.has(id))
+            return;
+        this.compiledCache.set(id, {});
+        this.evictCompiledCacheIfNeeded();
+    }
+    evictCompiledCacheIfNeeded() {
+        if (this.compiledCache.size <= this.COMPILED_CACHE_MAX)
+            return;
+        while (this.compiledCache.size > this.COMPILED_CACHE_MAX) {
+            const oldestKey = this.compiledCache.keys().next().value;
+            if (!oldestKey)
+                return;
+            this.compiledCache.delete(oldestKey);
         }
-        return sizeCheck.context;
     }
-}
+};
 exports.DefaultWorkflowService = DefaultWorkflowService;
-exports.defaultWorkflowService = new DefaultWorkflowService();
+exports.DefaultWorkflowService = DefaultWorkflowService = __decorate([
+    (0, tsyringe_1.singleton)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_js_1.DI.Storage.Primary)),
+    __param(1, (0, tsyringe_1.inject)(validation_engine_1.ValidationEngine)),
+    __param(2, (0, tsyringe_1.inject)(workflow_compiler_1.WorkflowCompiler)),
+    __param(3, (0, tsyringe_1.inject)(workflow_interpreter_1.WorkflowInterpreter)),
+    __metadata("design:paramtypes", [Object, validation_engine_1.ValidationEngine,
+        workflow_compiler_1.WorkflowCompiler,
+        workflow_interpreter_1.WorkflowInterpreter])
+], DefaultWorkflowService);

package/dist/application/use-cases/get-next-step.d.ts

@@ -1,13 +1,9 @@
 import { WorkflowService } from '../services/workflow-service';
-import { WorkflowStep, WorkflowGuidance } from '../../types/mcp-types';
 import { ConditionContext } from '../../utils/condition-evaluator';
-export declare function createGetNextStep(service: WorkflowService): (workflowId: string, completedSteps: string[], context?: ConditionContext) => Promise<{
-    step: WorkflowStep | null;
-    guidance: WorkflowGuidance;
+import type { ExecutionState } from '../../domain/execution/state';
+import type { WorkflowEvent } from '../../domain/execution/event';
+export declare function createGetNextStep(service: WorkflowService): (workflowId: string, state: ExecutionState, event?: WorkflowEvent, context?: ConditionContext) => Promise<import("neverthrow").Result<{
+    state: ExecutionState;
+    next: import("../services/workflow-interpreter").NextStep | null;
     isComplete: boolean;
-}>;
-export declare function getNextStep(service: WorkflowService, workflowId: string, completedSteps: string[], context?: ConditionContext): Promise<{
-    step: WorkflowStep | null;
-    guidance: WorkflowGuidance;
-    isComplete: boolean;
-}>;
+}, import("../../domain/execution/error").DomainError>>;