@flowgram.ai/runtime-js 0.2.21 → 0.2.23

package/dist/index.js

@@ -240,8 +240,27 @@ var FlowGramNode = /* @__PURE__ */ ((FlowGramNode22) => {
   FlowGramNode22["Loop"] = "loop";
   FlowGramNode22["Comment"] = "comment";
   FlowGramNode22["Group"] = "group";
+  FlowGramNode22["BlockStart"] = "block-start";
+  FlowGramNode22["BlockEnd"] = "block-end";
   return FlowGramNode22;
 })(FlowGramNode || {});
+var ConditionOperation = /* @__PURE__ */ ((ConditionOperation2) => {
+  ConditionOperation2["EQ"] = "eq";
+  ConditionOperation2["NEQ"] = "neq";
+  ConditionOperation2["GT"] = "gt";
+  ConditionOperation2["GTE"] = "gte";
+  ConditionOperation2["LT"] = "lt";
+  ConditionOperation2["LTE"] = "lte";
+  ConditionOperation2["IN"] = "in";
+  ConditionOperation2["NIN"] = "nin";
+  ConditionOperation2["CONTAINS"] = "contains";
+  ConditionOperation2["NOT_CONTAINS"] = "not_contains";
+  ConditionOperation2["IS_EMPTY"] = "is_empty";
+  ConditionOperation2["IS_NOT_EMPTY"] = "is_not_empty";
+  ConditionOperation2["IS_TRUE"] = "is_true";
+  ConditionOperation2["IS_FALSE"] = "is_false";
+  return ConditionOperation2;
+})(ConditionOperation || {});
 var IEngine = Symbol.for("Engine");
 var IExecutor = Symbol.for("Executor");
 var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
@@ -253,6 +272,14 @@ var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
   return WorkflowStatus2;
 })(WorkflowStatus || {});
 var IValidation = Symbol.for("Validation");
+var WorkflowMessageType = /* @__PURE__ */ ((WorkflowMessageType2) => {
+  WorkflowMessageType2["Log"] = "log";
+  WorkflowMessageType2["Info"] = "info";
+  WorkflowMessageType2["Debug"] = "debug";
+  WorkflowMessageType2["Error"] = "error";
+  WorkflowMessageType2["Warn"] = "warning";
+  return WorkflowMessageType2;
+})(WorkflowMessageType || {});
 
 // src/nodes/start/index.ts
 var StartExecutor = class {
@@ -268,26 +295,130 @@ var StartExecutor = class {
 
 // src/nodes/loop/index.ts
 var import_lodash_es = require("lodash-es");
+
+// src/infrastructure/utils/uuid.ts
+var import_uuid = require("uuid");
+var uuid = import_uuid.v4;
+
+// src/infrastructure/utils/runtime-type.ts
+var WorkflowRuntimeType;
+((WorkflowRuntimeType2) => {
+  WorkflowRuntimeType2.getWorkflowType = (value) => {
+    if (value === null || value === void 0) {
+      return WorkflowVariableType.Null;
+    }
+    if (typeof value === "string") {
+      return WorkflowVariableType.String;
+    }
+    if (typeof value === "boolean") {
+      return WorkflowVariableType.Boolean;
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return WorkflowVariableType.Integer;
+      }
+      return WorkflowVariableType.Number;
+    }
+    if (Array.isArray(value)) {
+      return WorkflowVariableType.Array;
+    }
+    if (typeof value === "object") {
+      return WorkflowVariableType.Object;
+    }
+    return null;
+  };
+  WorkflowRuntimeType2.isMatchWorkflowType = (value, type) => {
+    const workflowType = (0, WorkflowRuntimeType2.getWorkflowType)(value);
+    if (!workflowType) {
+      return false;
+    }
+    return workflowType === type;
+  };
+  WorkflowRuntimeType2.isTypeEqual = (leftType, rightType) => {
+    if (leftType === WorkflowVariableType.Number && rightType === WorkflowVariableType.Integer || leftType === WorkflowVariableType.Integer && rightType === WorkflowVariableType.Number) {
+      return true;
+    }
+    return leftType === rightType;
+  };
+  WorkflowRuntimeType2.getArrayItemsType = (types) => {
+    const expectedType = types[0];
+    types.forEach((type) => {
+      if (type !== expectedType) {
+        throw new Error(`array items type must be same, expect ${expectedType}, but got ${type}`);
+      }
+    });
+    return expectedType;
+  };
+})(WorkflowRuntimeType || (WorkflowRuntimeType = {}));
+
+// src/infrastructure/utils/traverse-nodes.ts
+function traverseNodes(startNode, getConnectedNodes) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  const traverse = (node) => {
+    for (const connectedNode of getConnectedNodes(node)) {
+      if (!visited.has(connectedNode.id)) {
+        visited.add(connectedNode.id);
+        result.push(connectedNode);
+        traverse(connectedNode);
+      }
+    }
+  };
+  traverse(startNode);
+  return result;
+}
+
+// src/infrastructure/utils/compare-node-groups.ts
+function compareNodeGroups(groupA, groupB) {
+  const flatA = groupA.flat();
+  const setA = /* @__PURE__ */ new Map();
+  flatA.forEach((node) => {
+    setA.set(node.id, node);
+  });
+  const flatB = groupB.flat();
+  const setB = /* @__PURE__ */ new Map();
+  flatB.forEach((node) => {
+    setB.set(node.id, node);
+  });
+  const common = [];
+  const uniqueToA = [];
+  const uniqueToB = [];
+  setA.forEach((node, id) => {
+    if (setB.has(id)) {
+      common.push(node);
+    } else {
+      uniqueToA.push(node);
+    }
+  });
+  setB.forEach((node, id) => {
+    if (!setA.has(id)) {
+      uniqueToB.push(node);
+    }
+  });
+  return {
+    common,
+    uniqueToA,
+    uniqueToB
+  };
+}
+
+// src/nodes/loop/index.ts
 var LoopExecutor = class {
   constructor() {
     this.type = FlowGramNode.Loop;
   }
   async execute(context) {
     const loopNodeID = context.node.id;
-    const loopArrayResult = context.runtime.state.parseRef(context.node.data.batchFor);
-    this.checkLoopArray(loopArrayResult);
-    const loopArray = loopArrayResult.value;
-    const itemsType = loopArrayResult.itemsType;
     const engine = context.container.get(IEngine);
+    const { value: loopArray, itemsType } = this.getLoopArrayVariable(context);
     const subNodes = context.node.children;
-    const startSubNodes = subNodes.filter((node) => node.prev.length === 0);
-    if (loopArray.length === 0 || startSubNodes.length === 0) {
-      return {
-        outputs: {}
-      };
+    const blockStartNode = subNodes.find((node) => node.type === FlowGramNode.BlockStart);
+    if (!blockStartNode) {
+      throw new Error("block start node not found");
     }
-    for (let i = 0; i < loopArray.length; i++) {
-      const loopItem = loopArray[i];
+    const blockOutputs = [];
+    for (let index = 0; index < loopArray.length; index++) {
+      const loopItem = loopArray[index];
       const subContext = context.runtime.sub();
       subContext.variableStore.setVariable({
         nodeID: `${loopNodeID}_locals`,
@@ -295,33 +426,99 @@ var LoopExecutor = class {
         type: itemsType,
         value: loopItem
       });
-      await Promise.all(
-        startSubNodes.map(
-          (node) => engine.executeNode({
-            context: subContext,
-            node
-          })
-        )
-      );
+      subContext.variableStore.setVariable({
+        nodeID: `${loopNodeID}_locals`,
+        key: "index",
+        type: WorkflowVariableType.Number,
+        value: index
+      });
+      await engine.executeNode({
+        context: subContext,
+        node: blockStartNode
+      });
+      const blockOutput = this.getBlockOutput(context, subContext);
+      blockOutputs.push(blockOutput);
     }
+    this.setLoopNodeOutputs(context, blockOutputs);
+    const outputs = this.combineBlockOutputs(context, blockOutputs);
     return {
-      outputs: {}
+      outputs
     };
   }
-  checkLoopArray(loopArrayResult) {
-    const loopArray = loopArrayResult?.value;
+  getLoopArrayVariable(executionContext) {
+    const loopNodeData = executionContext.node.data;
+    const LoopArrayVariable = executionContext.runtime.state.parseRef(
+      loopNodeData.loopFor
+    );
+    this.checkLoopArray(LoopArrayVariable);
+    return LoopArrayVariable;
+  }
+  checkLoopArray(LoopArrayVariable) {
+    const loopArray = LoopArrayVariable?.value;
     if (!loopArray || (0, import_lodash_es.isNil)(loopArray) || !Array.isArray(loopArray)) {
-      throw new Error("batchFor is required");
+      throw new Error("loopFor is required");
     }
-    const loopArrayType = loopArrayResult.type;
+    const loopArrayType = LoopArrayVariable.type;
     if (loopArrayType !== WorkflowVariableType.Array) {
-      throw new Error("batchFor must be an array");
+      throw new Error("loopFor must be an array");
     }
-    const loopArrayItemType = loopArrayResult.itemsType;
+    const loopArrayItemType = LoopArrayVariable.itemsType;
     if ((0, import_lodash_es.isNil)(loopArrayItemType)) {
-      throw new Error("batchFor items must be array items");
+      throw new Error("loopFor items must be array items");
     }
   }
+  getBlockOutput(executionContext, subContext) {
+    const loopOutputsDeclare = this.getLoopOutputsDeclare(executionContext);
+    const blockOutput = Object.entries(loopOutputsDeclare).reduce(
+      (acc, [outputName, outputRef]) => {
+        const outputVariable = subContext.state.parseRef(outputRef);
+        if (!outputVariable) {
+          return acc;
+        }
+        return {
+          ...acc,
+          [outputName]: outputVariable
+        };
+      },
+      {}
+    );
+    return blockOutput;
+  }
+  setLoopNodeOutputs(executionContext, blockOutputs) {
+    const loopNode = executionContext.node;
+    const loopOutputsDeclare = this.getLoopOutputsDeclare(executionContext);
+    const loopOutputNames = Object.keys(loopOutputsDeclare);
+    loopOutputNames.forEach((outputName) => {
+      const outputVariables = blockOutputs.map((blockOutput) => blockOutput[outputName]);
+      const outputTypes = outputVariables.map((fieldVariable) => fieldVariable.type);
+      const itemsType = WorkflowRuntimeType.getArrayItemsType(outputTypes);
+      const value = outputVariables.map((fieldVariable) => fieldVariable.value);
+      executionContext.runtime.variableStore.setVariable({
+        nodeID: loopNode.id,
+        key: outputName,
+        type: WorkflowVariableType.Array,
+        itemsType,
+        value
+      });
+    });
+  }
+  combineBlockOutputs(executionContext, blockOutputs) {
+    const loopOutputsDeclare = this.getLoopOutputsDeclare(executionContext);
+    const loopOutputNames = Object.keys(loopOutputsDeclare);
+    const loopOutput = loopOutputNames.reduce(
+      (outputs, outputName) => ({
+        ...outputs,
+        [outputName]: blockOutputs.map((blockOutput) => blockOutput[outputName].value)
+      }),
+      {}
+    );
+    return loopOutput;
+  }
+  getLoopOutputsDeclare(executionContext) {
+    const loopNodeData = executionContext.node.data;
+    const loopOutputsDeclare = loopNodeData.loopOutputs ?? {};
+    return loopOutputsDeclare;
+  }
 };
 
 // src/nodes/llm/index.ts
@@ -384,67 +581,89 @@ var EndExecutor = class {
   }
 };
 
+// src/nodes/empty/index.ts
+var BlockStartExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.BlockStart;
+  }
+  async execute(context) {
+    return {
+      outputs: {}
+    };
+  }
+};
+var BlockEndExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.BlockEnd;
+  }
+  async execute(context) {
+    return {
+      outputs: {}
+    };
+  }
+};
+
 // src/nodes/condition/index.ts
 var import_lodash_es9 = require("lodash-es");
 
 // src/nodes/condition/rules.ts
 var conditionRules = {
   [WorkflowVariableType.String]: {
-    ["eq" /* EQ */]: WorkflowVariableType.String,
-    ["neq" /* NEQ */]: WorkflowVariableType.String,
-    ["contains" /* CONTAINS */]: WorkflowVariableType.String,
-    ["not_contains" /* NOT_CONTAINS */]: WorkflowVariableType.String,
-    ["in" /* IN */]: WorkflowVariableType.Array,
-    ["nin" /* NIN */]: WorkflowVariableType.Array,
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.String,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.String
+    [ConditionOperation.EQ]: WorkflowVariableType.String,
+    [ConditionOperation.NEQ]: WorkflowVariableType.String,
+    [ConditionOperation.CONTAINS]: WorkflowVariableType.String,
+    [ConditionOperation.NOT_CONTAINS]: WorkflowVariableType.String,
+    [ConditionOperation.IN]: WorkflowVariableType.Array,
+    [ConditionOperation.NIN]: WorkflowVariableType.Array,
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.String,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.String
   },
   [WorkflowVariableType.Number]: {
-    ["eq" /* EQ */]: WorkflowVariableType.Number,
-    ["neq" /* NEQ */]: WorkflowVariableType.Number,
-    ["gt" /* GT */]: WorkflowVariableType.Number,
-    ["gte" /* GTE */]: WorkflowVariableType.Number,
-    ["lt" /* LT */]: WorkflowVariableType.Number,
-    ["lte" /* LTE */]: WorkflowVariableType.Number,
-    ["in" /* IN */]: WorkflowVariableType.Array,
-    ["nin" /* NIN */]: WorkflowVariableType.Array,
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.EQ]: WorkflowVariableType.Number,
+    [ConditionOperation.NEQ]: WorkflowVariableType.Number,
+    [ConditionOperation.GT]: WorkflowVariableType.Number,
+    [ConditionOperation.GTE]: WorkflowVariableType.Number,
+    [ConditionOperation.LT]: WorkflowVariableType.Number,
+    [ConditionOperation.LTE]: WorkflowVariableType.Number,
+    [ConditionOperation.IN]: WorkflowVariableType.Array,
+    [ConditionOperation.NIN]: WorkflowVariableType.Array,
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Integer]: {
-    ["eq" /* EQ */]: WorkflowVariableType.Integer,
-    ["neq" /* NEQ */]: WorkflowVariableType.Integer,
-    ["gt" /* GT */]: WorkflowVariableType.Integer,
-    ["gte" /* GTE */]: WorkflowVariableType.Integer,
-    ["lt" /* LT */]: WorkflowVariableType.Integer,
-    ["lte" /* LTE */]: WorkflowVariableType.Integer,
-    ["in" /* IN */]: WorkflowVariableType.Array,
-    ["nin" /* NIN */]: WorkflowVariableType.Array,
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.EQ]: WorkflowVariableType.Integer,
+    [ConditionOperation.NEQ]: WorkflowVariableType.Integer,
+    [ConditionOperation.GT]: WorkflowVariableType.Integer,
+    [ConditionOperation.GTE]: WorkflowVariableType.Integer,
+    [ConditionOperation.LT]: WorkflowVariableType.Integer,
+    [ConditionOperation.LTE]: WorkflowVariableType.Integer,
+    [ConditionOperation.IN]: WorkflowVariableType.Array,
+    [ConditionOperation.NIN]: WorkflowVariableType.Array,
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Boolean]: {
-    ["eq" /* EQ */]: WorkflowVariableType.Boolean,
-    ["neq" /* NEQ */]: WorkflowVariableType.Boolean,
-    ["is_true" /* IS_TRUE */]: WorkflowVariableType.Null,
-    ["is_false" /* IS_FALSE */]: WorkflowVariableType.Null,
-    ["in" /* IN */]: WorkflowVariableType.Array,
-    ["nin" /* NIN */]: WorkflowVariableType.Array,
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.EQ]: WorkflowVariableType.Boolean,
+    [ConditionOperation.NEQ]: WorkflowVariableType.Boolean,
+    [ConditionOperation.IS_TRUE]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_FALSE]: WorkflowVariableType.Null,
+    [ConditionOperation.IN]: WorkflowVariableType.Array,
+    [ConditionOperation.NIN]: WorkflowVariableType.Array,
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Object]: {
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Array]: {
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Null]: {
-    ["eq" /* EQ */]: WorkflowVariableType.Null,
-    ["is_empty" /* IS_EMPTY */]: WorkflowVariableType.Null,
-    ["is_not_empty" /* IS_NOT_EMPTY */]: WorkflowVariableType.Null
+    [ConditionOperation.EQ]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
   }
 };
 
@@ -453,34 +672,34 @@ var import_lodash_es3 = require("lodash-es");
 var conditionStringHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "eq" /* EQ */) {
+  if (operator === ConditionOperation.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === "neq" /* NEQ */) {
+  if (operator === ConditionOperation.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === "contains" /* CONTAINS */) {
+  if (operator === ConditionOperation.CONTAINS) {
     const rightValue = condition.rightValue;
     return leftValue.includes(rightValue);
   }
-  if (operator === "not_contains" /* NOT_CONTAINS */) {
+  if (operator === ConditionOperation.NOT_CONTAINS) {
     const rightValue = condition.rightValue;
     return !leftValue.includes(rightValue);
   }
-  if (operator === "in" /* IN */) {
+  if (operator === ConditionOperation.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === "nin" /* NIN */) {
+  if (operator === ConditionOperation.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es3.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es3.isNil)(leftValue);
   }
   return false;
@@ -491,10 +710,10 @@ var import_lodash_es4 = require("lodash-es");
 var conditionObjectHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es4.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es4.isNil)(leftValue);
   }
   return false;
@@ -505,42 +724,42 @@ var import_lodash_es5 = require("lodash-es");
 var conditionNumberHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "eq" /* EQ */) {
+  if (operator === ConditionOperation.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === "neq" /* NEQ */) {
+  if (operator === ConditionOperation.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === "gt" /* GT */) {
+  if (operator === ConditionOperation.GT) {
     const rightValue = condition.rightValue;
     return leftValue > rightValue;
   }
-  if (operator === "gte" /* GTE */) {
+  if (operator === ConditionOperation.GTE) {
     const rightValue = condition.rightValue;
     return leftValue >= rightValue;
   }
-  if (operator === "lt" /* LT */) {
+  if (operator === ConditionOperation.LT) {
     const rightValue = condition.rightValue;
     return leftValue < rightValue;
   }
-  if (operator === "lte" /* LTE */) {
+  if (operator === ConditionOperation.LTE) {
     const rightValue = condition.rightValue;
     return leftValue <= rightValue;
   }
-  if (operator === "in" /* IN */) {
+  if (operator === ConditionOperation.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === "nin" /* NIN */) {
+  if (operator === ConditionOperation.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es5.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es5.isNil)(leftValue);
   }
   return false;
@@ -551,13 +770,13 @@ var import_lodash_es6 = require("lodash-es");
 var conditionNullHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "eq" /* EQ */) {
+  if (operator === ConditionOperation.EQ) {
     return (0, import_lodash_es6.isNil)(leftValue) && (0, import_lodash_es6.isNil)(condition.rightValue);
   }
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es6.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es6.isNil)(leftValue);
   }
   return false;
@@ -568,32 +787,32 @@ var import_lodash_es7 = require("lodash-es");
 var conditionBooleanHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "eq" /* EQ */) {
+  if (operator === ConditionOperation.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === "neq" /* NEQ */) {
+  if (operator === ConditionOperation.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === "is_true" /* IS_TRUE */) {
+  if (operator === ConditionOperation.IS_TRUE) {
     return leftValue === true;
   }
-  if (operator === "is_false" /* IS_FALSE */) {
+  if (operator === ConditionOperation.IS_FALSE) {
     return leftValue === false;
   }
-  if (operator === "in" /* IN */) {
+  if (operator === ConditionOperation.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === "nin" /* NIN */) {
+  if (operator === ConditionOperation.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es7.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es7.isNil)(leftValue);
   }
   return false;
@@ -604,10 +823,10 @@ var import_lodash_es8 = require("lodash-es");
 var conditionArrayHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return (0, import_lodash_es8.isNil)(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !(0, import_lodash_es8.isNil)(leftValue);
   }
   return false;
@@ -639,9 +858,7 @@ var ConditionExecutor = class {
     const parsedConditions = conditions.map((item) => this.parseCondition(item, context)).filter((item) => this.checkCondition(item));
     const activatedCondition = parsedConditions.find((item) => this.handleCondition(item));
     if (!activatedCondition) {
-      return {
-        outputs: {}
-      };
+      throw new Error("no condition is activated");
     }
     return {
       outputs: {},
@@ -696,7 +913,9 @@ var WorkflowRuntimeNodeExecutors = [
   EndExecutor,
   LLMExecutor,
   ConditionExecutor,
-  LoopExecutor
+  LoopExecutor,
+  BlockStartExecutor,
+  BlockEndExecutor
 ];
 
 // src/domain/validation/index.ts
@@ -730,52 +949,6 @@ var WorkflowRuntimeExecutor = class {
   }
 };
 
-// src/infrastructure/utils/uuid.ts
-var import_uuid = require("uuid");
-var uuid = import_uuid.v4;
-
-// src/infrastructure/utils/runtime-type.ts
-var WorkflowRuntimeType;
-((WorkflowRuntimeType2) => {
-  WorkflowRuntimeType2.getWorkflowType = (value) => {
-    if (value === null || value === void 0) {
-      return WorkflowVariableType.Null;
-    }
-    if (typeof value === "string") {
-      return WorkflowVariableType.String;
-    }
-    if (typeof value === "boolean") {
-      return WorkflowVariableType.Boolean;
-    }
-    if (typeof value === "number") {
-      if (Number.isInteger(value)) {
-        return WorkflowVariableType.Integer;
-      }
-      return WorkflowVariableType.Number;
-    }
-    if (Array.isArray(value)) {
-      return WorkflowVariableType.Array;
-    }
-    if (typeof value === "object") {
-      return WorkflowVariableType.Object;
-    }
-    return null;
-  };
-  WorkflowRuntimeType2.isMatchWorkflowType = (value, type) => {
-    const workflowType = (0, WorkflowRuntimeType2.getWorkflowType)(value);
-    if (!workflowType) {
-      return false;
-    }
-    return workflowType === type;
-  };
-  WorkflowRuntimeType2.isTypeEqual = (leftType, rightType) => {
-    if (leftType === WorkflowVariableType.Number && rightType === WorkflowVariableType.Integer || leftType === WorkflowVariableType.Integer && rightType === WorkflowVariableType.Number) {
-      return true;
-    }
-    return leftType === rightType;
-  };
-})(WorkflowRuntimeType || (WorkflowRuntimeType = {}));
-
 // src/domain/task/index.ts
 var WorkflowRuntimeTask = class _WorkflowRuntimeTask {
   constructor(params) {
@@ -795,6 +968,85 @@ var WorkflowRuntimeTask = class _WorkflowRuntimeTask {
   }
 };
 
+// src/domain/message/message-value-object/index.ts
+var WorkflowRuntimeMessage;
+((WorkflowRuntimeMessage2) => {
+  WorkflowRuntimeMessage2.create = (params) => {
+    const message = {
+      id: uuid(),
+      ...params
+    };
+    if (!params.timestamp) {
+      message.timestamp = Date.now();
+    }
+    return message;
+  };
+})(WorkflowRuntimeMessage || (WorkflowRuntimeMessage = {}));
+
+// src/domain/message/message-center/index.ts
+var WorkflowRuntimeMessageCenter = class {
+  init() {
+    this.messages = {
+      [WorkflowMessageType.Log]: [],
+      [WorkflowMessageType.Info]: [],
+      [WorkflowMessageType.Debug]: [],
+      [WorkflowMessageType.Error]: [],
+      [WorkflowMessageType.Warn]: []
+    };
+  }
+  dispose() {
+  }
+  log(data) {
+    const message = WorkflowRuntimeMessage.create({
+      type: WorkflowMessageType.Log,
+      ...data
+    });
+    this.messages[WorkflowMessageType.Log].push(message);
+    return message;
+  }
+  info(data) {
+    const message = WorkflowRuntimeMessage.create({
+      type: WorkflowMessageType.Info,
+      ...data
+    });
+    this.messages[WorkflowMessageType.Info].push(message);
+    return message;
+  }
+  debug(data) {
+    const message = WorkflowRuntimeMessage.create({
+      type: WorkflowMessageType.Debug,
+      ...data
+    });
+    this.messages[WorkflowMessageType.Debug].push(message);
+    return message;
+  }
+  error(data) {
+    const message = WorkflowRuntimeMessage.create({
+      type: WorkflowMessageType.Error,
+      ...data
+    });
+    this.messages[WorkflowMessageType.Error].push(message);
+    return message;
+  }
+  warn(data) {
+    const message = WorkflowRuntimeMessage.create({
+      type: WorkflowMessageType.Warn,
+      ...data
+    });
+    this.messages[WorkflowMessageType.Warn].push(message);
+    return message;
+  }
+  export() {
+    return {
+      [WorkflowMessageType.Log]: this.messages[WorkflowMessageType.Log].slice(),
+      [WorkflowMessageType.Info]: this.messages[WorkflowMessageType.Info].slice(),
+      [WorkflowMessageType.Debug]: this.messages[WorkflowMessageType.Debug].slice(),
+      [WorkflowMessageType.Error]: this.messages[WorkflowMessageType.Error].slice(),
+      [WorkflowMessageType.Warn]: this.messages[WorkflowMessageType.Warn].slice()
+    };
+  }
+};
+
 // src/domain/variable/variable-store/index.ts
 var import_lodash_es10 = require("lodash-es");
 
@@ -1144,7 +1396,7 @@ var WorkflowRuntimeSnapshot = class _WorkflowRuntimeSnapshot {
     this.id = uuid();
     this.data = data;
   }
-  addData(data) {
+  update(data) {
     Object.assign(this.data, data);
   }
   validate() {
@@ -1205,10 +1457,11 @@ var WorkflowRuntimeReport;
 
 // src/domain/report/reporter/index.ts
 var WorkflowRuntimeReporter = class {
-  constructor(ioCenter, snapshotCenter, statusCenter) {
+  constructor(ioCenter, snapshotCenter, statusCenter, messageCenter) {
     this.ioCenter = ioCenter;
     this.snapshotCenter = snapshotCenter;
     this.statusCenter = statusCenter;
+    this.messageCenter = messageCenter;
   }
   init() {
   }
@@ -1219,7 +1472,8 @@ var WorkflowRuntimeReporter = class {
       inputs: this.ioCenter.inputs,
       outputs: this.ioCenter.outputs,
       workflowStatus: this.statusCenter.workflow.export(),
-      reports: this.nodeReports()
+      reports: this.nodeReports(),
+      messages: this.messageCenter.export()
     });
     return report;
   }
@@ -1357,6 +1611,12 @@ var WorkflowRuntimeNode = class {
   get next() {
     return this._next;
   }
+  get successors() {
+    return traverseNodes(this, (node) => node.next);
+  }
+  get predecessors() {
+    return traverseNodes(this, (node) => node.prev);
+  }
   get isBranch() {
     return this.ports.outputs.length > 1;
   }
@@ -1594,6 +1854,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.ioCenter = data.ioCenter;
     this.snapshotCenter = data.snapshotCenter;
     this.statusCenter = data.statusCenter;
+    this.messageCenter = data.messageCenter;
     this.reporter = data.reporter;
   }
   init(params) {
@@ -1604,6 +1865,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.ioCenter.init(inputs);
     this.snapshotCenter.init();
     this.statusCenter.init();
+    this.messageCenter.init();
     this.reporter.init();
   }
   dispose() {
@@ -1617,6 +1879,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.ioCenter.dispose();
     this.snapshotCenter.dispose();
     this.statusCenter.dispose();
+    this.messageCenter.dispose();
     this.reporter.dispose();
   }
   sub() {
@@ -1628,6 +1891,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       ioCenter: this.ioCenter,
       snapshotCenter: this.snapshotCenter,
       statusCenter: this.statusCenter,
+      messageCenter: this.messageCenter,
       reporter: this.reporter,
       variableStore,
       state
@@ -1645,7 +1909,13 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     const ioCenter = new WorkflowRuntimeIOCenter();
     const snapshotCenter = new WorkflowRuntimeSnapshotCenter();
     const statusCenter = new WorkflowRuntimeStatusCenter();
-    const reporter = new WorkflowRuntimeReporter(ioCenter, snapshotCenter, statusCenter);
+    const messageCenter = new WorkflowRuntimeMessageCenter();
+    const reporter = new WorkflowRuntimeReporter(
+      ioCenter,
+      snapshotCenter,
+      statusCenter,
+      messageCenter
+    );
     return new _WorkflowRuntimeContext({
       document,
       variableStore,
@@ -1653,6 +1923,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       ioCenter,
       snapshotCenter,
       statusCenter,
+      messageCenter,
       reporter
     });
   }
@@ -1681,11 +1952,14 @@ var WorkflowRuntimeEngine = class {
       return;
     }
     context.statusCenter.nodeStatus(node.id).process();
+    const snapshot = context.snapshotCenter.create({
+      nodeID: node.id,
+      data: node.data
+    });
+    let nextNodes = [];
     try {
       const inputs = context.state.getNodeInputs(node);
-      const snapshot = context.snapshotCenter.create({
-        nodeID: node.id,
-        data: node.data,
+      snapshot.update({
         inputs
       });
       const result = await this.executor.execute({
@@ -1698,17 +1972,23 @@ var WorkflowRuntimeEngine = class {
         return;
       }
       const { outputs, branch } = result;
-      snapshot.addData({ outputs, branch });
+      snapshot.update({ outputs, branch });
       context.state.setNodeOutputs({ node, outputs });
       context.state.addExecutedNode(node);
       context.statusCenter.nodeStatus(node.id).success();
-      const nextNodes = this.getNextNodes({ node, branch, context });
-      await this.executeNext({ node, nextNodes, context });
+      nextNodes = this.getNextNodes({ node, branch, context });
     } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : "An unknown error occurred";
+      snapshot.update({ error: errorMessage });
+      context.messageCenter.error({
+        nodeID: node.id,
+        message: errorMessage
+      });
       context.statusCenter.nodeStatus(node.id).fail();
       console.error(e);
-      return;
+      throw e;
     }
+    await this.executeNext({ node, nextNodes, context });
   }
   async process(context) {
     const startNode = context.document.start;
@@ -1720,7 +2000,7 @@ var WorkflowRuntimeEngine = class {
       return outputs;
     } catch (e) {
       context.statusCenter.workflow.fail();
-      throw e;
+      return {};
     }
   }
   canExecuteNode(params) {
@@ -1744,8 +2024,11 @@ var WorkflowRuntimeEngine = class {
     const nextNodeIDs = new Set(targetPort.edges.map((edge) => edge.to.id));
     const nextNodes = allNextNodes.filter((nextNode) => nextNodeIDs.has(nextNode.id));
     const skipNodes = allNextNodes.filter((nextNode) => !nextNodeIDs.has(nextNode.id));
-    skipNodes.forEach((skipNode) => {
-      context.state.addExecutedNode(skipNode);
+    const nextGroups = nextNodes.map((nextNode) => [nextNode, ...nextNode.successors]);
+    const skipGroups = skipNodes.map((skipNode) => [skipNode, ...skipNode.successors]);
+    const { uniqueToB: skippedNodes } = compareNodeGroups(nextGroups, skipGroups);
+    skippedNodes.forEach((node2) => {
+      context.state.addExecutedNode(node2);
     });
     return nextNodes;
   }