@ai-setting/roy-agent-core 1.5.43 → 1.5.44

package/dist/shared/@ai-setting/{roy-agent-core-2jnzv9at.js → roy-agent-core-38dkek2y.js}

@@ -9,12 +9,18 @@ import {
   init_skill_node,
   init_tool_node,
   init_workflow_node
-} from "./roy-agent-core-jvatggbb.js";
+} from "./roy-agent-core-6vxg2gmr.js";
 import {
+  TemplateResolver,
+  init_template_resolver
+} from "./roy-agent-core-v002ynpa.js";
+import {
+  WorkflowError,
   createWorkflowEvent,
   init_event,
-  init_types
-} from "./roy-agent-core-5x94xmt6.js";
+  init_types,
+  init_workflow_error
+} from "./roy-agent-core-qnrf2aw6.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
@@ -129,12 +135,14 @@ class DAGManager {
   nodeMap;
   extendedDefinition = null;
   cachedAnalysis = null;
-  constructor(workflow) {
+  allowCycles;
+  constructor(workflow, options) {
     if (!workflow.nodes || workflow.nodes.length === 0) {
       throw new Error("At least one node is required");
     }
     this.workflow = workflow;
     this.nodeMap = new Map;
+    this.allowCycles = options?.allowCycles ?? false;
     for (const node of workflow.nodes) {
       if (node.id === "") {
         throw new Error("Node ID cannot be empty");
@@ -386,7 +394,7 @@ class DAGManager {
     }
     return result;
   }
-  validate() {
+  validate(options) {
     const errors = [];
     const nodeIds = new Set;
     for (const node of this.workflow.nodes) {
@@ -407,7 +415,7 @@ class DAGManager {
         }
       }
     }
-    if (this.isCyclic()) {
+    if (!this.allowCycles && !options?.skipCycleCheck && this.isCyclic()) {
       errors.push("Workflow contains a cycle");
     }
     return {
@@ -455,6 +463,27 @@ class DAGManager {
     const analysis = this.analyze();
     return analysis.dependents.get(nodeId) || [];
   }
+  getDownstreamUntil(fromNodeId, untilNodeId) {
+    const result = [];
+    const visited = new Set;
+    const queue = [...this.getDependents(fromNodeId)];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (visited.has(nodeId))
+        continue;
+      visited.add(nodeId);
+      result.push(nodeId);
+      if (nodeId === untilNodeId) {
+        continue;
+      }
+      for (const dependent of this.getDependents(nodeId)) {
+        if (!visited.has(dependent)) {
+          queue.push(dependent);
+        }
+      }
+    }
+    return result;
+  }
   getDefinition() {
     return this.workflow;
   }
@@ -467,6 +496,20 @@ class DAGManager {
   getNodeCount() {
     return this.nodeMap.size;
   }
+  buildEdges(explicitEdges = []) {
+    const derivedEdges = [];
+    const explicitEdgeSet = new Set(explicitEdges.map((e) => `${e.from}->${e.to}`));
+    for (const node of this.workflow.nodes) {
+      const deps = node.depends_on || [];
+      for (const dep of deps) {
+        const edgeKey = `${dep}->${node.id}`;
+        if (!explicitEdgeSet.has(edgeKey)) {
+          derivedEdges.push({ from: dep, to: node.id });
+        }
+      }
+    }
+    return [...explicitEdges, ...derivedEdges];
+  }
 }
 var init_dag_manager = () => {};
 
@@ -542,6 +585,10 @@ class Scheduler {
     return this.ready.has(nodeId);
   }
   markCompleted(nodeId) {
+    if (nodeId === "__end__" || nodeId === "__END__") {
+      logger.debug(`[Scheduler] Workflow marked as completed via __end__`);
+      return;
+    }
     this.running.delete(nodeId);
     this.ready.delete(nodeId);
     this.pending.delete(nodeId);
@@ -569,6 +616,21 @@ class Scheduler {
     }
     this.skipped.add(nodeId);
   }
+  unmarkSkipped(nodeId) {
+    if (!this.skipped.has(nodeId)) {
+      return;
+    }
+    this.skipped.delete(nodeId);
+    this.pending.add(nodeId);
+  }
+  resetNodeForReEntry(nodeId) {
+    this.running.delete(nodeId);
+    this.completed.delete(nodeId);
+    this.failed.delete(nodeId);
+    this.skipped.delete(nodeId);
+    this.ready.delete(nodeId);
+    this.pending.add(nodeId);
+  }
   reset() {
     this.running.clear();
     this.completed.clear();
@@ -593,6 +655,11 @@ class Scheduler {
       skipped: Array.from(this.skipped).sort()
     };
   }
+  markCompletedFromRestore(nodeIds) {
+    for (const nodeId of nodeIds) {
+      this.markCompleted(nodeId);
+    }
+  }
   updateReadyNodes(completedNodes) {
     const allCompleted = new Set(completedNodes);
     for (const nodeId of this.completed) {
@@ -616,8 +683,70 @@ class Scheduler {
   setParallelLimit(limit) {
     this.options.parallelLimit = limit;
   }
+  getOutgoingEdges(nodeId, edges) {
+    return edges.filter((edge) => edge.from === nodeId);
+  }
+  processEdgesAfterCompletion(completedNodeId, edges, templateResolver, loopEnabled) {
+    const result = {
+      toStart: [],
+      reEntries: [],
+      skipped: [],
+      resetNodes: []
+    };
+    const completedNode = this.dagManager.getNode(completedNodeId);
+    if (completedNode?.condition) {
+      const conditionMet = templateResolver.evaluateCondition(completedNode.condition);
+      if (!conditionMet) {
+        for (const edge of this.getOutgoingEdges(completedNodeId, edges)) {
+          this.markSkipped(edge.to);
+          result.skipped.push({
+            nodeId: edge.to,
+            reason: `Inline condition false on node "${completedNodeId}"`
+          });
+        }
+        return result;
+      }
+    }
+    const outgoingEdges = this.getOutgoingEdges(completedNodeId, edges);
+    for (const edge of outgoingEdges) {
+      const conditionMet = !edge.when || templateResolver.evaluateCondition(edge.when);
+      if (conditionMet) {
+        if (this.skipped.has(edge.to)) {
+          this.unmarkSkipped(edge.to);
+        }
+        const isReEntry = loopEnabled && this.completed.has(edge.to);
+        const canStart = loopEnabled ? !this.running.has(edge.to) && !this.failed.has(edge.to) : !this.completed.has(edge.to) && !this.running.has(edge.to) && !this.failed.has(edge.to);
+        if (canStart) {
+          if (isReEntry) {
+            const downstream = this.dagManager.getDownstreamUntil(edge.to, completedNodeId);
+            for (const nodeId of downstream) {
+              this.resetNodeForReEntry(nodeId);
+              result.resetNodes.push(nodeId);
+            }
+            this.resetNodeForReEntry(edge.to);
+            result.resetNodes.push(edge.to);
+            result.reEntries.push(edge.to);
+          }
+          result.toStart.push(edge.to);
+        }
+      } else {
+        if (!this.skipped.has(edge.to)) {
+          result.skipped.push({
+            nodeId: edge.to,
+            reason: edge.when ? `Edge condition false: ${edge.when}` : "Edge condition false"
+          });
+        }
+        this.markSkipped(edge.to);
+      }
+    }
+    return result;
+  }
 }
-var init_scheduler = () => {};
+var logger;
+var init_scheduler = __esm(() => {
+  init_logger();
+  logger = createLogger("workflow.scheduler");
+});
 
 // src/env/workflow/engine/executor.ts
 var Executor;
@@ -972,11 +1101,16 @@ var init_agent_node = __esm(() => {
     async execute(context) {
       const startTime = Date.now();
       try {
-        const config = this.definition.config || {};
+        const config = context.resolvedConfig ?? this.definition.config ?? {};
         const agentType = config.agent_type || "general";
-        const promptTemplate = config.prompt || "";
         const options = config.options || {};
-        const resolvedPrompt = this.resolveTemplate(promptTemplate, context);
+        let resolvedPrompt;
+        if (context.resolvedConfig && context.templateResolver) {
+          resolvedPrompt = config.prompt || "";
+        } else {
+          const promptTemplate = config.prompt || "";
+          resolvedPrompt = context.templateResolver?.resolveValue(promptTemplate) ?? promptTemplate;
+        }
         if (this.agentRunner.registerAgent && this.agentRunner.hasAgent) {
           if (!this.agentRunner.hasAgent(agentType)) {
             this.agentRunner.registerAgent(agentType, {
@@ -1082,142 +1216,9 @@ var init_agent_node = __esm(() => {
       }
       return agentSessionId;
     }
-    resolveTemplate(template, context) {
-      if (!template) {
-        return "";
-      }
-      let resolved = template;
-      resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-        let value = this.getNestedValue(context.input, path);
-        if (value === undefined && context.workflowInput) {
-          value = this.getNestedValue(context.workflowInput, path);
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{inputs\.([^}]+)\}\}/g, (match, path) => {
-        let value = this.getNestedValue(context.input, path);
-        if (value === undefined && context.workflowInput) {
-          value = this.getNestedValue(context.workflowInput, path);
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
-        if (path.startsWith("input.") || path.startsWith("nodes.")) {
-          return match;
-        }
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      return resolved;
-    }
-    stringifyValue(value, originalTemplate) {
-      if (value === undefined) {
-        return originalTemplate;
-      }
-      if (value === null) {
-        return "null";
-      }
-      if (typeof value === "string") {
-        return value;
-      }
-      return JSON.stringify(value);
-    }
-    extractFromWrapper(value) {
-      if (value === null || value === undefined) {
-        return value;
-      }
-      if (typeof value !== "object") {
-        return value;
-      }
-      if ("result" in value && "metadata" in value) {
-        return value.result;
-      }
-      if ("output" in value) {
-        return value.output;
-      }
-      return value;
-    }
-    getNestedValue(obj, path) {
-      if (!obj) {
-        return;
-      }
-      if ("input" in obj && path in obj["input"]) {
-        return obj["input"][path];
-      }
-      return path.split(".").reduce((current, key) => {
-        if (current && typeof current === "object") {
-          return current[key];
-        }
-        return;
-      }, obj);
-    }
   };
   __legacyDecorateClassTS([
-    TracedAs("agent.node.execute", { recordParams: true, recordResult: true, log: true })
+    TracedAs("workflow.agent.execute", { log: true })
   ], AgentNode.prototype, "execute", null);
   __legacyDecorateClassTS([
     TracedAs("agent.node.createAgentSubSession", { recordParams: true, recordResult: true, log: true })
@@ -1226,16 +1227,17 @@ var init_agent_node = __esm(() => {
 
 // src/env/workflow/nodes/ask-user-node.ts
 class AskUserNode {
+  definition;
   type = "ask_user";
   id;
-  config;
   constructor(definition) {
+    this.definition = definition;
     this.id = definition.id;
-    this.config = definition.config || {};
   }
   async execute(context) {
-    const query = this.config.query || "确认继续吗？";
-    const options = this.config.options;
+    const config = context.resolvedConfig ?? this.definition.config ?? {};
+    const query = config.query || "确认继续吗？";
+    const options = config.options;
     const fullQuery = options ? `${query} (选项: ${options.join(", ")})` : query;
     await context.eventBus.publish(createNodeInterruptEvent(context.runId, this.id, this.type, fullQuery));
     throw new AskUserError(context.runId, context.sessionId, this.id, this.type, query);
@@ -1348,7 +1350,7 @@ var init_node_registry = __esm(() => {
 
 // src/env/workflow/engine/engine.ts
 import { EventEmitter } from "events";
-var logger, WorkflowEngine;
+var logger2, WorkflowEngine;
 var init_engine = __esm(() => {
   init_event();
   init_workflow_hil();
@@ -1359,7 +1361,9 @@ var init_engine = __esm(() => {
   init_node_registry();
   init_logger();
   init_decorator();
-  logger = createLogger("workflow:engine");
+  init_template_resolver();
+  init_workflow_error();
+  logger2 = createLogger("workflow:engine");
   WorkflowEngine = class WorkflowEngine extends EventEmitter {
     activeSessions = new Map;
     sessionIdCounter = 0;
@@ -1416,7 +1420,7 @@ var init_engine = __esm(() => {
           metadata
         });
       }
-      logger.info(`[WorkflowEngine] Created session: ${sessionId}`);
+      logger2.info(`[WorkflowEngine] Created session: ${sessionId}`);
       return sessionId;
     }
     async run(sessionId, options) {
@@ -1486,24 +1490,26 @@ var init_engine = __esm(() => {
             }
           });
           metadata.input = { ...existingInput, ...newInput };
-          logger.info(`[WorkflowEngine] Updated session ${sessionId} input with resume user input`);
+          logger2.info(`[WorkflowEngine] Updated session ${sessionId} input with resume user input`);
         }
       }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode } = await import("./roy-agent-core-ffb9fq4v.js");
+      const { inferNextNode, extractResumeInfo } = await import("./roy-agent-core-23gw9c4s.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
+      const resumeInfo = extractResumeInfo(messages);
       const resumePoint = inferNextNode(messages, {
         entryNode: entryNode !== "__default_entry__" ? entryNode : undefined,
         edges: undefined
       });
       const sessionState = await this.initializeSessionState(sessionId, workflowDef, workflowId, workflowName, options);
       this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, resumePoint, options);
+      return this.runWithResume(sessionId, resumePoint, resumeInfo, options);
     }
     async initializeSessionState(sessionId, definition, workflowId, workflowName, options) {
-      const dagManager = new DAGManager(definition);
-      const validation = dagManager.validate();
+      const loopEnabled = options?.loopEnabled ?? definition.config?.loopEnabled ?? false;
+      const dagManager = new DAGManager(definition, { allowCycles: loopEnabled });
+      const validation = dagManager.validate({ skipCycleCheck: loopEnabled });
       if (!validation.valid) {
         throw new Error(`Invalid workflow: ${validation.errors.join(", ")}`);
       }
@@ -1516,10 +1522,15 @@ var init_engine = __esm(() => {
         debug: options?.debug ?? definition.config?.debug ?? false
       };
       const executor = new Executor(this.nodeRegistry, eventBus, executorOptions, this.sessionComponent);
+      const workflowInput = options?.workflowInput ?? options?.input;
       const config = {
         parallelLimit,
         timeout: options?.timeout ?? definition.config?.timeout ?? null,
-        debug: options?.debug ?? definition.config?.debug ?? false
+        debug: options?.debug ?? definition.config?.debug ?? false,
+        strict: options?.strict ?? definition.config?.strict ?? false,
+        maxIterations: options?.maxIterations ?? definition.config?.maxIterations ?? 100,
+        loopEnabled,
+        workflowInput
       };
       const abortController = new AbortController;
       let resolveCompleted;
@@ -1546,12 +1557,14 @@ var init_engine = __esm(() => {
         resolveCompleted,
         rejectCompleted,
         workflowHistory: [],
-        agentSessions: new Map
+        agentSessions: new Map,
+        edges: dagManager.buildEdges(definition.edges || []),
+        loopIterationCount: 0
       };
       this.setupEventHandlers(sessionState);
       return sessionState;
     }
-    async runWithResume(sessionId, resumePoint, options) {
+    async runWithResume(sessionId, resumePoint, resumeInfo, options) {
       const sessionState = this.activeSessions.get(sessionId);
       if (!sessionState) {
         throw new Error(`Session not found: ${sessionId}`);
@@ -1580,12 +1593,17 @@ var init_engine = __esm(() => {
       } else if (options?.input && typeof options.input === "object") {
         inputForExecution = options.input;
       }
+      if (resumeInfo?.nodeOutputs) {
+        const completedNodeIds = Array.from(resumeInfo.nodeOutputs.keys());
+        sessionState.scheduler.markCompletedFromRestore(completedNodeIds);
+      }
       this.scheduleAndExecute(sessionState, {
         input: inputForExecution,
         pendingNodeId,
-        agentSessionId
+        agentSessionId,
+        restoredOutputs: resumeInfo?.nodeOutputs
       }).catch((error) => {
-        logger.error(`Workflow ${sessionId} scheduling error:`, error);
+        logger2.error(`Workflow ${sessionId} scheduling error:`, error);
         this.failWorkflow(sessionState, error);
       });
       if (options?.sync !== false) {
@@ -1600,7 +1618,7 @@ var init_engine = __esm(() => {
       const sessionId = await this.createSession(workflow, options);
       const sessionState = await this.initializeSessionState(sessionId, definition, workflowId, workflowName, options);
       this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, { type: "entry_node" }, options);
+      return this.runWithResume(sessionId, { type: "entry_node" }, undefined, options);
     }
     async pause(sessionId) {
       const sessionState = this.activeSessions.get(sessionId);
@@ -1620,7 +1638,7 @@ var init_engine = __esm(() => {
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.paused", this.getRunIdFromSessionId(sessionId), {}));
-      logger.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
+      logger2.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
     }
     async stop(sessionId, reason) {
       const sessionState = this.activeSessions.get(sessionId);
@@ -1659,15 +1677,12 @@ var init_engine = __esm(() => {
       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);
         if (event.output && typeof event.output === "object" && "workflowHistory" in event.output) {
           const messages = event.output.workflowHistory;
           if (Array.isArray(messages)) {
             sessionState.workflowHistory.push(...messages);
           }
         }
-        this.checkAndFinalize(sessionState);
       });
       eventBus.on("node.failed", async (event) => {
         if (event.type !== "node.failed")
@@ -1678,7 +1693,7 @@ var init_engine = __esm(() => {
       eventBus.on("node.interrupt", async (event) => {
         if (event.type !== "node.interrupt")
           return;
-        logger.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
+        logger2.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
         sessionState.status = "paused";
         sessionState.abortController.abort();
         if (this.sessionComponent) {
@@ -1720,6 +1735,14 @@ var init_engine = __esm(() => {
     async scheduleAndExecute(sessionState, options) {
       const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
       const { input: globalInput, pendingNodeId, agentSessionId, restoredOutputs } = options || {};
+      if (globalInput) {
+        sessionState.config.workflowInput = {
+          ...sessionState.config.workflowInput || {},
+          ...globalInput
+        };
+      }
+      sessionState.loopIterationCount = 0;
+      const maxIterations = sessionState.config.maxIterations;
       if (restoredOutputs) {
         for (const [nodeId, output] of restoredOutputs) {
           nodeOutputs.set(nodeId, output);
@@ -1739,7 +1762,7 @@ var init_engine = __esm(() => {
             break;
           if (scheduled >= (sessionState.config.parallelLimit ?? Infinity))
             break;
-          await this.startNode(sessionState, nodeId, globalInput);
+          await this.startNode(sessionState, nodeId, sessionState.config.workflowInput);
           scheduled++;
         }
         return true;
@@ -1757,6 +1780,12 @@ var init_engine = __esm(() => {
         if (state.pending.length === 0 && state.running.length === 0) {
           break;
         }
+        if (sessionState.config.loopEnabled && sessionState.loopIterationCount >= maxIterations) {
+          logger2.error(`[WorkflowEngine] Max loop iterations ${maxIterations} exceeded`);
+          sessionState.rejectCompleted(new WorkflowError(`Workflow exceeded maximum loop iterations: ${maxIterations}`));
+          await this.stop(sessionState.sessionId, "Max iterations exceeded");
+          return;
+        }
         try {
           await this.waitForNextNodeEvent(sessionState, abortController.signal);
         } catch {
@@ -1809,15 +1838,8 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
         return;
       }
-      await this.writeNodeStart(sessionId, nodeId, nodeDef.type, input);
-      const context = this.createExecutionContext(sessionState, nodeId, input);
-      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);
-      });
+      const context = this.buildNodeContext(sessionState, nodeId, input);
+      await this.validateAndExecute(nodeDef, context, sessionState);
     }
     async writeNodeStart(sessionId, nodeId, nodeType, input) {
       if (this.sessionComponent) {
@@ -1862,7 +1884,10 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
         return;
       }
-      const context = this.createExecutionContext(sessionState, nodeId, { userQuery: options?.userQuery }, true);
+      const context = this.buildNodeContext(sessionState, nodeId, {
+        ...sessionState.config.workflowInput || {},
+        ...options?.userQuery ? { userQuery: options.userQuery } : {}
+      });
       if (options?.agentSessionId) {
         context.agentSessionId = options.agentSessionId;
       }
@@ -1883,16 +1908,103 @@ var init_engine = __esm(() => {
           }
         }
       }
-      executor.executeNode(nodeDef, context).catch((error) => {
+      await this.validateAndExecute(nodeDef, context, sessionState);
+    }
+    async preExecuteValidation(nodeId, nodeDef, context, options) {
+      if (!nodeDef) {
+        logger2.warn(`Node ${nodeId} has no configuration`);
+        return;
+      }
+      const config = nodeDef.config || {};
+      if (context.debug) {
+        logger2.debug(`Pre-execute validation for node ${nodeId}`, {
+          workflowInput: context.workflowInput,
+          previousOutputs: Array.from(context.previousOutputs.keys()),
+          hasTemplateResolver: !!context.templateResolver
+        });
+      }
+      if (context.templateResolver) {
+        const { unresolved } = context.templateResolver.resolveAndValidate(config);
+        if (unresolved.length > 0) {
+          if (options?.strict) {
+            context.templateResolver.resolveStrict(config, nodeId);
+          }
+          logger2.warn(`[WorkflowEngine] Node "${nodeId}" has unresolved templates:`, unresolved);
+        }
+      }
+    }
+    async validateAndExecute(nodeDef, context, sessionState) {
+      const { scheduler, executor, eventBus } = sessionState;
+      const { nodeId } = context;
+      const strictMode = sessionState.config?.strict ?? false;
+      try {
+        await this.preExecuteValidation(nodeId, nodeDef, context, { strict: strictMode });
+      } catch (err) {
+        logger2.error(`[WorkflowEngine] Strict validation failed for node ${nodeId}:`, err);
+        scheduler.markFailed(nodeId);
+        return;
+      }
+      try {
+        const result = await executor.executeNode(nodeDef, context);
+        if (result.error) {
+          return;
+        }
+        sessionState.nodeOutputs.set(nodeId, result.output);
+        scheduler.markCompleted(nodeId);
+        if (result.output && typeof result.output === "object" && "workflowHistory" in result.output) {
+          const messages = result.output.workflowHistory;
+          if (Array.isArray(messages)) {
+            sessionState.workflowHistory.push(...messages);
+          }
+        }
+        await this.processConditionalEdgesAfterCompletion(sessionState, nodeId);
+        this.checkAndFinalize(sessionState);
+      } catch (error) {
         if (error instanceof AskUserError) {
-          const event = createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId);
-          eventBus.publish(event);
+          await eventBus.publish(createNodeInterruptEvent(context.runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
           return;
         }
         scheduler.markFailed(nodeId);
+      }
+    }
+    async processConditionalEdgesAfterCompletion(sessionState, completedNodeId) {
+      if (!sessionState.edges || sessionState.edges.length === 0) {
+        return;
+      }
+      const { scheduler, eventBus } = sessionState;
+      const runId = this.getRunIdFromSessionId(sessionState.sessionId);
+      const templateResolver = new TemplateResolver({
+        input: sessionState.config.workflowInput || {},
+        previousOutputs: new Map(sessionState.nodeOutputs)
       });
+      logger2.debug(`[WorkflowEngine] Processing edges after "${completedNodeId}" completed. edges=${JSON.stringify(sessionState.edges)}`);
+      const edgeResult = scheduler.processEdgesAfterCompletion(completedNodeId, sessionState.edges, templateResolver, sessionState.config.loopEnabled);
+      logger2.debug(`[WorkflowEngine] Edge processing result: ${JSON.stringify(edgeResult)}`);
+      for (const nodeId of edgeResult.resetNodes) {
+        sessionState.nodeOutputs.delete(nodeId);
+      }
+      for (const { nodeId, reason } of edgeResult.skipped) {
+        await eventBus.publish(createWorkflowEvent("node.skipped", runId, {
+          node_id: nodeId,
+          reason
+        }));
+      }
+      if (edgeResult.reEntries.length > 0) {
+        sessionState.loopIterationCount += edgeResult.reEntries.length;
+        logger2.debug(`[WorkflowEngine] Loop iteration #${sessionState.loopIterationCount}: re-entering ${edgeResult.reEntries.join(", ")}`);
+      }
+      const workflowInput = sessionState.config.workflowInput || {};
+      for (const targetId of edgeResult.toStart) {
+        if (targetId === "__end__" || targetId === "__END__") {
+          logger2.info(`[WorkflowEngine] Workflow terminated via __end__ edge from node "${completedNodeId}"`);
+          scheduler.markCompleted("__end__");
+          await this.completeWorkflow(sessionState);
+        } else {
+          await this.startNode(sessionState, targetId, workflowInput);
+        }
+      }
     }
-    createExecutionContext(sessionState, nodeId, globalInput, forceGlobalInput) {
+    buildNodeContext(sessionState, nodeId, globalInput) {
       const nodeDef = sessionState.dagManager.getNode(nodeId);
       const runId = this.getRunIdFromSessionId(sessionState.sessionId);
       const deps = nodeDef.depends_on || [];
@@ -1903,15 +2015,15 @@ var init_engine = __esm(() => {
           input[depId] = depOutput;
         }
       }
-      const analysis = sessionState.dagManager.analyze();
-      const isEntryNode = analysis.entryNodes.includes(nodeId);
-      if ((isEntryNode || forceGlobalInput) && globalInput) {
-        Object.assign(input, globalInput);
-      }
+      const workflowInput = globalInput ?? sessionState.config.workflowInput ?? {};
+      const templateResolver = new TemplateResolver({
+        input: workflowInput,
+        previousOutputs: new Map(sessionState.nodeOutputs)
+      });
       const askUser = (query) => {
         throw new AskUserError(runId, sessionState.sessionId, nodeId, nodeDef.type, query);
       };
-      return {
+      const context = {
         runId,
         sessionId: sessionState.sessionId,
         workflowName: sessionState.workflowName,
@@ -1924,8 +2036,12 @@ var init_engine = __esm(() => {
         nodeOutputs: sessionState.nodeOutputs,
         workflowHistory: sessionState.workflowHistory,
         sessionComponent: this.sessionComponent,
-        askUser
+        askUser,
+        workflowInput,
+        templateResolver,
+        resolvedConfig: templateResolver.resolveValue(nodeDef.config ?? {})
       };
+      return context;
     }
     checkAndFinalize(sessionState) {
       const state = sessionState.scheduler.getState();
@@ -1938,6 +2054,10 @@ var init_engine = __esm(() => {
       }
     }
     async completeWorkflow(sessionState) {
+      if (sessionState.status !== "running") {
+        return;
+      }
+      sessionState.status = "completed";
       const durationMs = Date.now() - sessionState.startedAt.getTime();
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
@@ -1964,6 +2084,10 @@ var init_engine = __esm(() => {
       this.cleanupSession(sessionState);
     }
     async failWorkflow(sessionState, error) {
+      if (sessionState.status !== "running") {
+        return;
+      }
+      sessionState.status = "failed";
       const durationMs = Date.now() - sessionState.startedAt.getTime();
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
@@ -2065,6 +2189,12 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "resumeNode", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.preExecuteValidation", { log: true })
+  ], WorkflowEngine.prototype, "preExecuteValidation", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.buildNodeContext", { log: true })
+  ], WorkflowEngine.prototype, "buildNodeContext", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.checkAndFinalize", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "checkAndFinalize", null);