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

package/dist/core/src/env/workflow/engine/engine.js

@@ -0,0 +1,1122 @@
+/**
+ * @fileoverview WorkflowEngine - Session-based workflow execution engine
+ *
+ * 基于 Session 实现 run/resume 机制：
+ * - Session 直接作为 workflow run 的实例
+ * - 使用 workflow.node.* 消息记录节点执行状态
+ * - resume 时从 Session 消息恢复状态
+ *
+ * @version v2.0
+ */
+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);
+};
+import { EventEmitter } from 'events';
+import { createWorkflowEvent } from "../types/event.js";
+import { createNodeInterruptEvent, AskUserError } from "../types/workflow-hil.js";
+import { DAGManager } from "./dag-manager.js";
+import { EventBus } from "./event-bus.js";
+import { Scheduler } from "./scheduler.js";
+import { Executor } from "./executor.js";
+import { NodeRegistry } from "./node-registry.js";
+import { createLogger } from "../../log-trace/logger.js";
+import { TracedAs } from "../../log-trace/decorator.js";
+// Logger
+const logger = createLogger("workflow:engine");
+// ============================================================================
+// WorkflowEngine Class
+// ============================================================================
+/**
+ * WorkflowEngine
+ *
+ * Session-based workflow execution engine.
+ * Uses Session to manage workflow run state and node execution history.
+ */
+export class WorkflowEngine extends EventEmitter {
+    /** 活跃的 session 状态，key 为 sessionId */
+    activeSessions = new Map();
+    /** Session ID 计数器 */
+    sessionIdCounter = 0;
+    /** Session component */
+    sessionComponent;
+    /** Node registry */
+    nodeRegistry;
+    /** Workflow repository for loading definitions during resume */
+    workflowRepository;
+    /**
+     * Create a new WorkflowEngine
+     */
+    constructor(nodeRegistry, sessionComponent, workflowRepository) {
+        super();
+        this.nodeRegistry = nodeRegistry;
+        this.sessionComponent = sessionComponent;
+        this.workflowRepository = workflowRepository;
+    }
+    /**
+     * Create a WorkflowEngine with automatic AgentComponent integration
+     */
+    static async create(options) {
+        const agentComponent = options.env?.getComponent('agent');
+        const sessionComponent = options.sessionComponent;
+        const nodeRegistry = new NodeRegistry({
+            toolRegistry: options.toolRegistry,
+            skillRegistry: options.skillRegistry,
+            agentComponent,
+            workflowRunner: options.workflowRunner,
+            sessionComponent,
+        });
+        return new WorkflowEngine(nodeRegistry, sessionComponent, options.workflowRepository);
+    }
+    // =========================================================================
+    // Session ID Utilities
+    // =========================================================================
+    /**
+     * Generate a unique run ID
+     */
+    generateRunId() {
+        const random = Math.random().toString(36).substring(2, 8);
+        return `run_${Date.now()}_${++this.sessionIdCounter}_${random}`;
+    }
+    /**
+     * Extract runId from sessionId
+     * sessionId format: workflow_{runId}
+     */
+    getRunIdFromSessionId(sessionId) {
+        return sessionId.replace(/^workflow_/, '');
+    }
+    /**
+     * Get session ID for a run
+     */
+    getSessionId(runId) {
+        return `workflow_${runId}`;
+    }
+    // =========================================================================
+    // Public API: Session Management
+    // =========================================================================
+    /**
+     * Create a new workflow session
+     *
+     * @param workflow - Workflow definition or entity
+     * @param options - Optional configuration
+     * @returns Promise resolving to sessionId (format: workflow_{runId})
+     */
+    async createSession(workflow, options) {
+        const definition = 'definition' in workflow
+            ? workflow.definition
+            : workflow;
+        const workflowId = 'id' in workflow
+            ? workflow.id
+            : `inline_${definition.name}`;
+        const workflowName = definition.name;
+        // Generate run ID and session ID
+        const runId = this.generateRunId();
+        const sessionId = this.getSessionId(runId);
+        // Create Session
+        const metadata = {
+            type: 'workflow',
+            workflowId,
+            workflowName,
+            workflowVersion: definition.version,
+            status: 'running',
+            input: options?.input,
+            agentSessions: [],
+        };
+        if (this.sessionComponent) {
+            await this.sessionComponent.create({
+                id: sessionId,
+                title: `Workflow: ${workflowName} (${runId})`,
+                metadata,
+            });
+        }
+        logger.info(`[WorkflowEngine] Created session: ${sessionId}`);
+        return sessionId;
+    }
+    /**
+     * Run a workflow by sessionId (unified entry point)
+     *
+     * This method supports both:
+     * 1. First run: session doesn't exist → create session, start from entry node
+     * 2. Resume: session exists with messages → infer next node from messages
+     *
+     * @param sessionId - Session ID (format: workflow_{runId} or any string)
+     * @param options - Optional configuration
+     * @returns Promise resolving to RunResult
+     */
+    async run(sessionId, options) {
+        // 1. Try to get existing session
+        let session = this.sessionComponent
+            ? await this.sessionComponent.get(sessionId)
+            : null;
+        let workflowDef = null;
+        let workflowId = '';
+        let workflowName = '';
+        if (session) {
+            // Session exists - load workflow definition
+            const metadata = session.metadata;
+            if (metadata.type === 'workflow' && metadata.workflowId) {
+                workflowDef = this.findDefinitionForWorkflow(metadata.workflowId);
+                workflowId = metadata.workflowId;
+                workflowName = metadata.workflowName;
+            }
+            if (!workflowDef && metadata.workflowName) {
+                workflowDef = this.findDefinitionForWorkflow(metadata.workflowName);
+                workflowId = metadata.workflowName;
+                workflowName = metadata.workflowName;
+            }
+        }
+        else {
+            // No session - this is a new run
+            if (!options?.workflowId) {
+                throw new Error('workflowId required for new session');
+            }
+            workflowDef = this.findDefinitionForWorkflow(options.workflowId);
+            if (!workflowDef) {
+                throw new Error(`Workflow not found: ${options.workflowId}`);
+            }
+            workflowId = options.workflowId;
+            workflowName = workflowDef.name;
+            // Create session
+            if (this.sessionComponent) {
+                const sessionMetadata = {
+                    type: 'workflow',
+                    workflowId,
+                    workflowName,
+                    workflowVersion: workflowDef.version,
+                    status: 'running',
+                };
+                await this.sessionComponent.create({
+                    id: sessionId,
+                    title: `Workflow: ${workflowName}`,
+                    metadata: sessionMetadata,
+                });
+                session = await this.sessionComponent.get(sessionId);
+            }
+        }
+        if (!session || !workflowDef) {
+            throw new Error(`Cannot start workflow: session or workflow not found`);
+        }
+        // 2. Check session status
+        const metadata = session.metadata;
+        if (metadata.status === 'completed') {
+            return { runId: this.getRunIdFromSessionId(sessionId), status: 'completed' };
+        }
+        if (metadata.status === 'failed') {
+            return { runId: this.getRunIdFromSessionId(sessionId), status: 'failed' };
+        }
+        // 3. Load messages and infer next node
+        const messages = this.sessionComponent
+            ? await this.sessionComponent.getMessages(sessionId)
+            : [];
+        // 4. Import and use session-recovery utilities
+        const { inferNextNode } = await import('../utils/session-recovery');
+        // Get entry node from workflow definition
+        const entry = workflowDef.entry;
+        const entryNode = Array.isArray(entry) ? entry[0] : entry;
+        const resumePoint = inferNextNode(messages, {
+            entryNode: entryNode !== '__default_entry__' ? entryNode : undefined,
+            edges: undefined, // edges not available in WorkflowDefinition, derived at runtime
+        });
+        // 5. Initialize session state and execute
+        const sessionState = await this.initializeSessionState(sessionId, workflowDef, workflowId, workflowName, options);
+        this.activeSessions.set(sessionId, sessionState);
+        // 6. Run with resume point
+        return this.runWithResume(sessionId, resumePoint, options);
+    }
+    /**
+     * Initialize session state
+     */
+    async initializeSessionState(sessionId, definition, workflowId, workflowName, options) {
+        // Create DAG manager
+        const dagManager = new DAGManager(definition);
+        // Validate DAG
+        const validation = dagManager.validate();
+        if (!validation.valid) {
+            throw new Error(`Invalid workflow: ${validation.errors.join(', ')}`);
+        }
+        // Get parallel limit
+        const parallelLimit = options?.parallelLimit
+            ?? definition.config?.parallel_limit
+            ?? null;
+        // Create scheduler
+        const scheduler = new Scheduler(dagManager, { parallelLimit });
+        // Create event bus
+        const eventBus = new EventBus();
+        // Create executor
+        const executorOptions = {
+            globalTimeout: options?.timeout ?? definition.config?.timeout ?? null,
+            globalRetry: definition.config?.retry ?? null,
+            debug: options?.debug ?? definition.config?.debug ?? false,
+        };
+        const executor = new Executor(this.nodeRegistry, eventBus, executorOptions, this.sessionComponent);
+        // Create engine config
+        const config = {
+            parallelLimit,
+            timeout: options?.timeout ?? definition.config?.timeout ?? null,
+            debug: options?.debug ?? definition.config?.debug ?? false,
+        };
+        // Create abort controller
+        const abortController = new AbortController();
+        // Create completion promise
+        let resolveCompleted;
+        let rejectCompleted;
+        const completedPromise = new Promise((resolve, reject) => {
+            resolveCompleted = resolve;
+            rejectCompleted = reject;
+        });
+        // Create session state
+        const sessionState = {
+            sessionId,
+            workflowId,
+            workflowName,
+            status: 'running',
+            startedAt: new Date(),
+            eventBus,
+            dagManager,
+            scheduler,
+            executor,
+            nodeRegistry: this.nodeRegistry,
+            nodeOutputs: new Map(),
+            config,
+            abortController,
+            completedPromise,
+            resolveCompleted,
+            rejectCompleted,
+            workflowHistory: [],
+            agentSessions: new Map(),
+        };
+        // Setup event handlers
+        this.setupEventHandlers(sessionState);
+        return sessionState;
+    }
+    /**
+     * Run with resume point
+     */
+    async runWithResume(sessionId, resumePoint, options) {
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const runId = this.getRunIdFromSessionId(sessionId);
+        // Publish workflow started event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.started', runId, {
+            workflow_name: sessionState.workflowName,
+            input: options?.input,
+        }));
+        // Determine what to execute based on resume point
+        let pendingNodeId;
+        let agentSessionId;
+        switch (resumePoint.type) {
+            case 'entry_node':
+            case 'next_nodes':
+                // Normal execution - scheduler will handle it
+                pendingNodeId = undefined;
+                break;
+            case 'resume_node':
+            case 'ask_user':
+                // Resume specific node
+                pendingNodeId = resumePoint.nodeId;
+                agentSessionId = resumePoint.agentSessionId;
+                break;
+        }
+        // Start scheduling
+        // Note: userResponse is extracted from input if it's a string (for resume)
+        const userResponse = typeof options?.input === 'string' ? options.input : undefined;
+        this.scheduleAndExecute(sessionState, {
+            input: options?.input,
+            pendingNodeId,
+            agentSessionId,
+            userResponse,
+        }).catch((error) => {
+            logger.error(`Workflow ${sessionId} scheduling error:`, error);
+            this.failWorkflow(sessionState, error);
+        });
+        // If sync mode, wait for completion
+        if (options?.sync !== false) {
+            return this.waitForCompletion(sessionId, options?.timeout);
+        }
+        return { runId, status: 'running' };
+    }
+    /**
+     * Convenience method to run a workflow directly
+     */
+    async runWorkflow(workflow, options) {
+        const definition = 'definition' in workflow
+            ? workflow.definition
+            : workflow;
+        const workflowId = 'id' in workflow
+            ? workflow.id
+            : `inline_${definition.name}`;
+        const workflowName = definition.name;
+        // Create session
+        const sessionId = await this.createSession(workflow, options);
+        // Initialize session state
+        const sessionState = await this.initializeSessionState(sessionId, definition, workflowId, workflowName, options);
+        this.activeSessions.set(sessionId, sessionState);
+        // Run with default entry node
+        return this.runWithResume(sessionId, { type: 'entry_node' }, options);
+    }
+    /**
+     * Pause a running workflow
+     */
+    async pause(sessionId) {
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        if (sessionState.status !== 'running') {
+            throw new Error(`Session ${sessionId} is not running (current: ${sessionState.status})`);
+        }
+        sessionState.status = 'paused';
+        sessionState.abortController.abort();
+        sessionState.executor.cancelAll();
+        // Update session metadata
+        if (this.sessionComponent) {
+            const metadata = await this.getSessionMetadata(sessionId);
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'paused' },
+            });
+        }
+        // Publish pause event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.paused', this.getRunIdFromSessionId(sessionId), {}));
+        logger.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
+    }
+    /**
+     * Resume a paused workflow
+     */
+    async resume(sessionId, options) {
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            // Session not in memory, try to restore from database
+            logger.info(`[WorkflowEngine] Session not in memory, attempting to restore from DB: ${sessionId}`);
+            return this.resumeFromDatabase(sessionId, options);
+        }
+        // Write resume message
+        if (options?.response) {
+            await this.writeNodeResume(sessionId, options.response);
+        }
+        if (sessionState.status === 'running') {
+            // Already running
+            return { runId: this.getRunIdFromSessionId(sessionId), status: 'running' };
+        }
+        if (sessionState.status !== 'paused') {
+            throw new Error(`Session ${sessionId} is not paused (current: ${sessionState.status})`);
+        }
+        // Resume state
+        sessionState.status = 'running';
+        sessionState.abortController = new AbortController();
+        // Update session metadata
+        if (this.sessionComponent) {
+            const metadata = await this.getSessionMetadata(sessionId);
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'running' },
+            });
+        }
+        // Publish resume event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.resumed', this.getRunIdFromSessionId(sessionId), {
+            userResponse: options?.response,
+        }));
+        // Restore runtime state from messages and continue execution
+        const runtimeState = await this.restoreRuntimeState(sessionId);
+        this.scheduleAndExecute(sessionState, {
+            pendingNodeId: runtimeState.pendingNodeId || undefined,
+            agentSessionId: runtimeState.agentSessionId,
+            userResponse: options?.response,
+            restoredOutputs: runtimeState.nodeOutputs,
+        });
+        return {
+            runId: this.getRunIdFromSessionId(sessionId),
+            status: 'running',
+        };
+    }
+    /**
+     * Resume from database when CLI restarts
+     */
+    async resumeFromDatabase(sessionId, options) {
+        // Get session
+        const session = await this.sessionComponent?.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const metadata = session.metadata;
+        if (metadata.type !== 'workflow') {
+            throw new Error(`Session is not a workflow session: ${sessionId}`);
+        }
+        if (metadata.status !== 'paused') {
+            throw new Error(`Workflow is not paused: ${sessionId}, status: ${metadata.status}`);
+        }
+        // Restore runtime state from messages
+        const runtimeState = await this.restoreRuntimeState(sessionId);
+        if (!runtimeState.pendingNodeId) {
+            throw new Error(`No pending node found in session: ${sessionId}`);
+        }
+        // Write resume message
+        if (options?.response) {
+            await this.writeNodeResume(sessionId, options.response);
+        }
+        // Update session metadata to running
+        if (this.sessionComponent) {
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'running' },
+            });
+        }
+        logger.info(`[WorkflowEngine] Resumed from database: ${sessionId}, pendingNode: ${runtimeState.pendingNodeId}`);
+        // Note: Cannot fully restore without workflow definition
+        // This is a current design limitation
+        throw new Error(`Cannot resume from database without workflow definition. ` +
+            `Session ${sessionId} is paused at node "${runtimeState.pendingNodeId}". ` +
+            `Please ensure the workflow is registered before resuming.`);
+    }
+    /**
+     * Restore runtime state from Session messages
+     */
+    async restoreRuntimeState(sessionId) {
+        const messages = this.sessionComponent
+            ? await this.sessionComponent.getMessages(sessionId)
+            : [];
+        const nodeOutputs = new Map();
+        let lastCallNodeId = null;
+        let lastInterruptMessage = null;
+        let agentSessionId;
+        for (const msg of messages) {
+            const msgMetadata = msg.metadata;
+            if (msgMetadata?.type === 'workflow.node.call') {
+                lastCallNodeId = msgMetadata.workflowNodeId;
+            }
+            else if (msgMetadata?.type === 'workflow.node.result') {
+                if (lastCallNodeId) {
+                    try {
+                        nodeOutputs.set(lastCallNodeId, JSON.parse(msg.content));
+                    }
+                    catch {
+                        nodeOutputs.set(lastCallNodeId, msg.content);
+                    }
+                }
+                lastCallNodeId = null;
+            }
+            else if (msgMetadata?.type === 'workflow.node.interrupt') {
+                lastInterruptMessage = msg;
+                lastCallNodeId = msgMetadata.workflowNodeId;
+                agentSessionId = msgMetadata.agentSessionId;
+            }
+        }
+        return {
+            nodeOutputs,
+            pendingNodeId: lastCallNodeId,
+            waitingForUser: !!lastInterruptMessage,
+            agentSessionId,
+            lastInterruptMessage,
+        };
+    }
+    /**
+     * Write node resume message
+     */
+    async writeNodeResume(sessionId, response) {
+        if (this.sessionComponent) {
+            await this.sessionComponent.addMessage(sessionId, {
+                role: 'workflow.node.resume',
+                content: response,
+                metadata: {
+                    type: 'workflow.node.resume',
+                    response,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+    }
+    /**
+     * Stop a running or paused workflow
+     */
+    async stop(sessionId, reason) {
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            // Not in memory, try to update database
+            if (this.sessionComponent) {
+                await this.sessionComponent.update(sessionId, {
+                    metadata: { status: 'stopped' },
+                });
+            }
+            return;
+        }
+        sessionState.status = 'stopped';
+        sessionState.abortController.abort();
+        sessionState.executor.cancelAll();
+        // Update session metadata
+        if (this.sessionComponent) {
+            const metadata = await this.getSessionMetadata(sessionId);
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'stopped' },
+            });
+        }
+        // Publish stop event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.stopped', this.getRunIdFromSessionId(sessionId), {
+            reason: reason ?? 'User requested stop',
+        }));
+        // Cleanup
+        this.cleanupSession(sessionState);
+    }
+    /**
+     * Get session status
+     */
+    getSessionStatus(sessionId) {
+        const sessionState = this.activeSessions.get(sessionId);
+        return sessionState?.status ?? null;
+    }
+    /**
+     * Check if session is active
+     */
+    isSessionActive(sessionId) {
+        return this.activeSessions.has(sessionId);
+    }
+    // =========================================================================
+    // Private Methods
+    // =========================================================================
+    /**
+     * Setup event handlers for a run
+     */
+    setupEventHandlers(sessionState) {
+        const { sessionId, eventBus, scheduler } = sessionState;
+        const runId = this.getRunIdFromSessionId(sessionId);
+        // Handle node completed
+        eventBus.on('node.completed', async (event) => {
+            if (event.type !== 'node.completed')
+                return;
+            sessionState.nodeOutputs.set(event.node_id, event.output);
+            scheduler.markCompleted(event.node_id);
+            // Accumulate workflow history
+            if (event.output && typeof event.output === 'object' && 'workflowHistory' in event.output) {
+                const messages = event.output.workflowHistory;
+                if (Array.isArray(messages)) {
+                    sessionState.workflowHistory.push(...messages);
+                }
+            }
+            // Check if workflow is complete
+            this.checkAndFinalize(sessionState);
+        });
+        // Handle node failed
+        eventBus.on('node.failed', async (event) => {
+            if (event.type !== 'node.failed')
+                return;
+            scheduler.markFailed(event.node_id);
+            await this.failWorkflow(sessionState, new Error(event.error.message));
+        });
+        // Handle node interrupt (ask_user pause)
+        eventBus.on('node.interrupt', async (event) => {
+            if (event.type !== 'node.interrupt')
+                return;
+            logger.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
+            sessionState.status = 'paused';
+            sessionState.abortController.abort();
+            // Update session metadata
+            if (this.sessionComponent) {
+                const metadata = await this.getSessionMetadata(sessionId);
+                await this.sessionComponent.update(sessionId, {
+                    metadata: { ...metadata, status: 'paused' },
+                });
+            }
+            // Publish workflow.paused event
+            await eventBus.publish(createWorkflowEvent('workflow.paused', runId, {
+                pendingNodeId: event.node_id,
+                query: event.query,
+            }));
+            // Write interrupt message to session
+            await this.writeNodeInterrupt(sessionId, event.node_id, event.node_type, event.query, event.agent_session_id);
+            // Resolve with paused status
+            sessionState.resolveCompleted({
+                runId,
+                status: 'paused',
+                pendingNodeId: event.node_id,
+                query: event.query,
+                agentSessionId: event.agent_session_id,
+            });
+        });
+    }
+    /**
+     * Write node interrupt message
+     */
+    async writeNodeInterrupt(sessionId, nodeId, nodeType, query, agentSessionId) {
+        if (this.sessionComponent) {
+            await this.sessionComponent.addMessage(sessionId, {
+                role: 'workflow.node.interrupt',
+                content: query,
+                metadata: {
+                    type: 'workflow.node.interrupt',
+                    workflowNodeId: nodeId,
+                    workflowNodeType: nodeType,
+                    query,
+                    agentSessionId,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+    }
+    /**
+     * Main scheduling loop
+     */
+    async scheduleAndExecute(sessionState, options) {
+        const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
+        const { input: globalInput, pendingNodeId, agentSessionId, userResponse, restoredOutputs } = options || {};
+        // Merge restored outputs if any
+        if (restoredOutputs) {
+            for (const [nodeId, output] of restoredOutputs) {
+                nodeOutputs.set(nodeId, output);
+            }
+        }
+        // Helper to schedule available nodes
+        const scheduleAvailableNodes = async () => {
+            const state = scheduler.getState();
+            const completedNodes = new Set(state.completed);
+            const readyNodes = scheduler.getReadyNodes(completedNodes);
+            const canStart = scheduler.canStartMore();
+            if (readyNodes.length === 0 || !canStart) {
+                return false;
+            }
+            let scheduled = 0;
+            for (const nodeId of readyNodes) {
+                if (!scheduler.canStartMore())
+                    break;
+                if (scheduled >= (sessionState.config.parallelLimit ?? Infinity))
+                    break;
+                await this.startNode(sessionState, nodeId, globalInput);
+                scheduled++;
+            }
+            return true;
+        };
+        // Initial scheduling
+        if (pendingNodeId) {
+            // Resume mode: only schedule the pending node
+            await this.resumeNode(sessionState, pendingNodeId, {
+                agentSessionId,
+                userResponse,
+            });
+        }
+        else {
+            await scheduleAvailableNodes();
+        }
+        // Event-driven loop
+        while (sessionState.status === 'running' && !abortController.signal.aborted) {
+            const state = scheduler.getState();
+            if (state.pending.length === 0 && state.running.length === 0) {
+                break;
+            }
+            try {
+                await this.waitForNextNodeEvent(sessionState, abortController.signal);
+            }
+            catch {
+                break;
+            }
+            await scheduleAvailableNodes();
+        }
+    }
+    /**
+     * Wait for next node event
+     */
+    waitForNextNodeEvent(sessionState, signal) {
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, 100);
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                sessionState.eventBus.off('node.completed', onCompleted);
+                sessionState.eventBus.off('node.failed', onFailed);
+            };
+            const onCompleted = (event) => {
+                if (event.type === 'node.completed') {
+                    cleanup();
+                    resolve();
+                }
+            };
+            const onFailed = (event) => {
+                if (event.type === 'node.failed') {
+                    cleanup();
+                    resolve();
+                }
+            };
+            sessionState.eventBus.on('node.completed', onCompleted);
+            sessionState.eventBus.on('node.failed', onFailed);
+            if (signal.aborted) {
+                cleanup();
+                resolve();
+            }
+        });
+    }
+    /**
+     * Start execution of a single node
+     */
+    async startNode(sessionState, nodeId, input) {
+        const { scheduler, executor, eventBus, dagManager } = sessionState;
+        const sessionId = sessionState.sessionId;
+        const runId = this.getRunIdFromSessionId(sessionId);
+        scheduler.markStarted(nodeId);
+        // Publish scheduled event
+        await eventBus.publish(createWorkflowEvent('node.scheduled', runId, {
+            node_id: nodeId,
+        }));
+        // Get node definition
+        const nodeDef = dagManager.getNode(nodeId);
+        if (!nodeDef) {
+            scheduler.markFailed(nodeId);
+            return;
+        }
+        // Write workflow.node.call message
+        await this.writeNodeCall(sessionId, nodeId, nodeDef.type, input);
+        // Create execution context
+        const context = this.createExecutionContext(sessionState, nodeId, input);
+        // Execute node
+        executor.executeNode(nodeDef, context).catch(async (error) => {
+            if (error instanceof AskUserError) {
+                await eventBus.publish(createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
+                return;
+            }
+            scheduler.markFailed(nodeId);
+        });
+    }
+    /**
+     * Write node call message
+     */
+    async writeNodeCall(sessionId, nodeId, nodeType, input) {
+        if (this.sessionComponent) {
+            await this.sessionComponent.addMessage(sessionId, {
+                role: 'workflow.node.call',
+                content: JSON.stringify({ input }),
+                metadata: {
+                    type: 'workflow.node.call',
+                    workflowNodeId: nodeId,
+                    workflowNodeType: nodeType,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+    }
+    /**
+     * Resume execution of a paused node
+     */
+    async resumeNode(sessionState, nodeId, options) {
+        const { scheduler, executor, eventBus, dagManager } = sessionState;
+        const sessionId = sessionState.sessionId;
+        const runId = this.getRunIdFromSessionId(sessionId);
+        scheduler.markStarted(nodeId);
+        // Publish resume event
+        await eventBus.publish(createWorkflowEvent('node.started', runId, {
+            node_id: nodeId,
+            agentSessionId: options?.agentSessionId,
+            userResponse: options?.userResponse,
+        }));
+        // Get node definition
+        const nodeDef = dagManager.getNode(nodeId);
+        if (!nodeDef) {
+            scheduler.markFailed(nodeId);
+            return;
+        }
+        // Create execution context
+        const context = this.createExecutionContext(sessionState, nodeId, undefined);
+        // Add resume options to context
+        if (options?.agentSessionId || options?.userResponse) {
+            context.agentSessionId = options.agentSessionId;
+            context.userResponse = options.userResponse;
+        }
+        // Execute node
+        executor.executeNode(nodeDef, context).catch((error) => {
+            if (error instanceof AskUserError) {
+                const event = createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId);
+                eventBus.publish(event);
+                return;
+            }
+            scheduler.markFailed(nodeId);
+        });
+    }
+    /**
+     * Create execution context for a node
+     */
+    createExecutionContext(sessionState, nodeId, globalInput) {
+        const nodeDef = sessionState.dagManager.getNode(nodeId);
+        const runId = this.getRunIdFromSessionId(sessionState.sessionId);
+        // Collect inputs from dependencies
+        const deps = nodeDef.depends_on || [];
+        const input = {};
+        for (const depId of deps) {
+            const depOutput = sessionState.nodeOutputs.get(depId);
+            if (depOutput !== undefined) {
+                input[depId] = depOutput;
+            }
+        }
+        // Merge global input if this is an entry node
+        const analysis = sessionState.dagManager.analyze();
+        if (analysis.entryNodes.includes(nodeId) && globalInput) {
+            Object.assign(input, globalInput);
+        }
+        // Ask user function
+        const askUser = (query) => {
+            throw new AskUserError(runId, sessionState.sessionId, nodeId, nodeDef.type, query);
+        };
+        return {
+            runId,
+            sessionId: sessionState.sessionId,
+            workflowName: sessionState.workflowName,
+            nodeId,
+            input,
+            previousOutputs: sessionState.nodeOutputs,
+            config: nodeDef.config ?? {},
+            debug: sessionState.config.debug,
+            eventBus: sessionState.eventBus,
+            nodeOutputs: sessionState.nodeOutputs,
+            workflowHistory: sessionState.workflowHistory,
+            sessionComponent: this.sessionComponent,
+            askUser,
+        };
+    }
+    /**
+     * Check if workflow is complete and finalize
+     */
+    checkAndFinalize(sessionState) {
+        const state = sessionState.scheduler.getState();
+        if (state.pending.length === 0 &&
+            state.running.length === 0 &&
+            state.ready.length === 0) {
+            if (state.failed.length > 0) {
+                this.failWorkflow(sessionState, new Error(`Nodes failed: ${state.failed.join(', ')}`));
+            }
+            else {
+                this.completeWorkflow(sessionState);
+            }
+        }
+    }
+    /**
+     * Complete a workflow successfully
+     */
+    async completeWorkflow(sessionState) {
+        const durationMs = Date.now() - sessionState.startedAt.getTime();
+        const sessionId = sessionState.sessionId;
+        const runId = this.getRunIdFromSessionId(sessionId);
+        // Collect output
+        const output = {};
+        for (const [nodeId, nodeOutput] of sessionState.nodeOutputs) {
+            output[nodeId] = nodeOutput;
+        }
+        // Update session metadata
+        if (this.sessionComponent) {
+            const metadata = await this.getSessionMetadata(sessionId);
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'completed' },
+            });
+        }
+        // Publish completed event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.completed', runId, {
+            result: output,
+            duration_ms: durationMs,
+        }), true);
+        // Resolve completion
+        sessionState.resolveCompleted({
+            runId,
+            status: 'completed',
+            output,
+            durationMs,
+        });
+        // Cleanup
+        this.cleanupSession(sessionState);
+    }
+    /**
+     * Fail a workflow
+     */
+    async failWorkflow(sessionState, error) {
+        const durationMs = Date.now() - sessionState.startedAt.getTime();
+        const sessionId = sessionState.sessionId;
+        const runId = this.getRunIdFromSessionId(sessionId);
+        sessionState.executor.cancelAll();
+        // Update session metadata
+        if (this.sessionComponent) {
+            const metadata = await this.getSessionMetadata(sessionId);
+            await this.sessionComponent.update(sessionId, {
+                metadata: { ...metadata, status: 'failed' },
+            });
+        }
+        // Publish failed event
+        await sessionState.eventBus.publish(createWorkflowEvent('workflow.failed', runId, {
+            error: { message: error.message, stack: error.stack },
+            failed_at: new Date().toISOString(),
+        }), true);
+        // Resolve with error
+        sessionState.resolveCompleted({
+            runId,
+            status: 'failed',
+            error: error.message,
+            durationMs,
+        });
+        // Cleanup
+        this.cleanupSession(sessionState);
+    }
+    /**
+     * Cleanup session resources
+     */
+    cleanupSession(sessionState) {
+        sessionState.eventBus.clear();
+        this.activeSessions.delete(sessionState.sessionId);
+    }
+    /**
+     * Wait for a run to complete
+     */
+    async waitForCompletion(sessionId, timeout) {
+        const sessionState = this.activeSessions.get(sessionId);
+        if (!sessionState) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const timeoutMs = timeout ?? 300000;
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Workflow execution timeout: ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+        return Promise.race([
+            sessionState.completedPromise,
+            timeoutPromise,
+        ]);
+    }
+    /**
+     * Get session metadata
+     */
+    async getSessionMetadata(sessionId) {
+        if (!this.sessionComponent) {
+            return { type: 'workflow', workflowId: '', workflowName: '', status: 'running' };
+        }
+        const session = await this.sessionComponent.get(sessionId);
+        return session?.metadata || { type: 'workflow', workflowId: '', workflowName: '', status: 'running' };
+    }
+    /**
+     * Find workflow definition from repository
+     */
+    findDefinitionForWorkflow(workflowIdOrName) {
+        if (!this.workflowRepository) {
+            return null;
+        }
+        // Try by ID first
+        let workflow = this.workflowRepository.getById(workflowIdOrName);
+        if (workflow)
+            return workflow.definition;
+        // Try by name
+        workflow = this.workflowRepository.getByName(workflowIdOrName);
+        if (workflow)
+            return workflow.definition;
+        return null;
+    }
+}
+__decorate([
+    TracedAs("workflow.engine.createSession", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "createSession", null);
+__decorate([
+    TracedAs("workflow.engine.run", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "run", null);
+__decorate([
+    TracedAs("workflow.engine.runWorkflow", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "runWorkflow", null);
+__decorate([
+    TracedAs("workflow.engine.pause", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "pause", null);
+__decorate([
+    TracedAs("workflow.engine.resume", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "resume", null);
+__decorate([
+    TracedAs("workflow.engine.resumeFromDatabase", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "resumeFromDatabase", null);
+__decorate([
+    TracedAs("workflow.engine.restoreRuntimeState", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "restoreRuntimeState", null);
+__decorate([
+    TracedAs("workflow.engine.writeNodeResume", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "writeNodeResume", null);
+__decorate([
+    TracedAs("workflow.engine.stop", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "stop", null);
+__decorate([
+    TracedAs("workflow.engine.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true }),
+    TracedAs("workflow.engine.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "writeNodeInterrupt", null);
+__decorate([
+    TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true, log: true }),
+    TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "scheduleAndExecute", null);
+__decorate([
+    TracedAs("workflow.engine.waitForNextNodeEvent", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, AbortSignal]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "waitForNextNodeEvent", null);
+__decorate([
+    TracedAs("workflow.engine.startNode", { recordParams: true, recordResult: true, log: true }),
+    TracedAs("workflow.engine.startNode", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "startNode", null);
+__decorate([
+    TracedAs("workflow.engine.writeNodeCall", { recordParams: true, recordResult: true, log: true }),
+    TracedAs("workflow.engine.writeNodeCall", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "writeNodeCall", null);
+__decorate([
+    TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true }),
+    TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "resumeNode", null);
+__decorate([
+    TracedAs("workflow.engine.checkAndFinalize", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], WorkflowEngine.prototype, "checkAndFinalize", null);
+__decorate([
+    TracedAs("workflow.engine.completeWorkflow", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "completeWorkflow", null);
+__decorate([
+    TracedAs("workflow.engine.failWorkflow", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Error]),
+    __metadata("design:returntype", Promise)
+], WorkflowEngine.prototype, "failWorkflow", null);
+//# sourceMappingURL=engine.js.map