@flowgram.ai/runtime-js 0.2.22 → 0.2.24

package/dist/esm/index.js

@@ -1,79 +1,78 @@
 // ../interface/dist/esm/index.js
+import z2 from "zod";
 import z from "zod";
 import z3 from "zod";
-import z2 from "zod";
 import z4 from "zod";
 import z5 from "zod";
 import z6 from "zod";
 import z7 from "zod";
+var WorkflowIOZodSchema = z.record(z.string(), z.any());
+var WorkflowSnapshotZodSchema = z.object({
+  id: z.string(),
+  nodeID: z.string(),
+  inputs: WorkflowIOZodSchema,
+  outputs: WorkflowIOZodSchema.optional(),
+  data: WorkflowIOZodSchema,
+  branch: z.string().optional()
+});
+var WorkflowStatusZodShape = {
+  status: z.string(),
+  terminated: z.boolean(),
+  startTime: z.number(),
+  endTime: z.number().optional(),
+  timeCost: z.number()
+};
+var WorkflowStatusZodSchema = z.object(WorkflowStatusZodShape);
+var WorkflowNodeReportZodSchema = z.object({
+  id: z.string(),
+  ...WorkflowStatusZodShape,
+  snapshots: z.array(WorkflowSnapshotZodSchema)
+});
+var WorkflowReportsZodSchema = z.record(z.string(), WorkflowNodeReportZodSchema);
+var WorkflowMessageZodSchema = z.object({
+  id: z.string(),
+  type: z.enum(["log", "info", "debug", "error", "warning"]),
+  message: z.string(),
+  nodeID: z.string().optional(),
+  timestamp: z.number()
+});
+var WorkflowMessagesZodSchema = z.record(
+  z.enum(["log", "info", "debug", "error", "warning"]),
+  z.array(WorkflowMessageZodSchema)
+);
+var WorkflowZodSchema = {
+  Inputs: WorkflowIOZodSchema,
+  Outputs: WorkflowIOZodSchema,
+  Status: WorkflowStatusZodSchema,
+  Snapshot: WorkflowSnapshotZodSchema,
+  Reports: WorkflowReportsZodSchema,
+  Messages: WorkflowMessagesZodSchema
+};
 var FlowGramAPIName = /* @__PURE__ */ ((FlowGramAPIName2) => {
   FlowGramAPIName2["ServerInfo"] = "ServerInfo";
   FlowGramAPIName2["TaskRun"] = "TaskRun";
   FlowGramAPIName2["TaskReport"] = "TaskReport";
   FlowGramAPIName2["TaskResult"] = "TaskResult";
   FlowGramAPIName2["TaskCancel"] = "TaskCancel";
-  FlowGramAPIName2["Validation"] = "Validation";
+  FlowGramAPIName2["TaskValidate"] = "TaskValidate";
   return FlowGramAPIName2;
 })(FlowGramAPIName || {});
-var ValidationDefine = {
-  name: "Validation",
+var TaskValidateDefine = {
+  name: "TaskValidate",
   method: "POST",
-  path: "/validation",
-  module: "Validation",
+  path: "/task/validate",
+  module: "Task",
   schema: {
-    input: z.object({
-      schema: z.string()
+    input: z2.object({
+      schema: z2.string(),
+      inputs: WorkflowZodSchema.Inputs
     }),
-    output: z.object({
-      valid: z.boolean(),
-      nodeErrors: z.array(
-        z.object({
-          message: z.string(),
-          nodeID: z.string()
-        })
-      ),
-      edgeErrors: z.array(
-        z.object({
-          message: z.string(),
-          edge: z.object({
-            sourceNodeID: z.string(),
-            targetNodeID: z.string(),
-            sourcePortID: z.string().optional(),
-            targetPortID: z.string().optional()
-          })
-        })
-      )
+    output: z2.object({
+      valid: z2.boolean(),
+      errors: z2.array(z2.string()).optional()
     })
   }
 };
-var WorkflowIOZodSchema = z2.record(z2.string(), z2.any());
-var WorkflowSnapshotZodSchema = z2.object({
-  id: z2.string(),
-  nodeID: z2.string(),
-  inputs: WorkflowIOZodSchema,
-  outputs: WorkflowIOZodSchema.optional(),
-  data: WorkflowIOZodSchema,
-  branch: z2.string().optional()
-});
-var WorkflowStatusZodShape = {
-  status: z2.string(),
-  terminated: z2.boolean(),
-  startTime: z2.number(),
-  endTime: z2.number().optional(),
-  timeCost: z2.number()
-};
-var WorkflowStatusZodSchema = z2.object(WorkflowStatusZodShape);
-var WorkflowZodSchema = {
-  Inputs: WorkflowIOZodSchema,
-  Outputs: WorkflowIOZodSchema,
-  Status: WorkflowStatusZodSchema,
-  Snapshot: WorkflowSnapshotZodSchema,
-  NodeReport: z2.object({
-    id: z2.string(),
-    ...WorkflowStatusZodShape,
-    snapshots: z2.array(WorkflowSnapshotZodSchema)
-  })
-};
 var TaskRunDefine = {
   name: "TaskRun",
   method: "POST",
@@ -115,7 +114,8 @@ var TaskReportDefine = {
       inputs: WorkflowZodSchema.Inputs,
       outputs: WorkflowZodSchema.Outputs,
       workflowStatus: WorkflowZodSchema.Status,
-      reports: z5.record(z5.string(), WorkflowZodSchema.NodeReport)
+      reports: WorkflowZodSchema.Reports,
+      messages: WorkflowZodSchema.Messages
     })
   }
 };
@@ -170,9 +170,9 @@ var FlowGramAPIs = {
     /* TaskCancel */
   ]: TaskCancelDefine,
   [
-    "Validation"
-    /* Validation */
-  ]: ValidationDefine
+    "TaskValidate"
+    /* TaskValidate */
+  ]: TaskValidateDefine
 };
 var FlowGramAPINames = Object.keys(FlowGramAPIs);
 var WorkflowPortType = /* @__PURE__ */ ((WorkflowPortType2) => {
@@ -200,8 +200,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) => {
@@ -213,6 +232,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 {
@@ -228,26 +255,329 @@ var StartExecutor = class {
 
 // src/nodes/loop/index.ts
 import { isNil } from "lodash-es";
+
+// src/infrastructure/utils/uuid.ts
+import { v4 } from "uuid";
+var 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/infrastructure/utils/json-schema-validator.ts
+var ROOT_PATH = "root";
+var isRootPath = (path) => path === ROOT_PATH;
+var validateValue = (value, schema, path) => {
+  if (schema.$ref) {
+    return { result: true };
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    if (!schema.enum.includes(value)) {
+      return {
+        result: false,
+        errorMessage: `Value at ${path} must be one of: ${schema.enum.join(
+          ", "
+        )}, but got: ${JSON.stringify(value)}`
+      };
+    }
+  }
+  switch (schema.type) {
+    case "boolean":
+      return validateBoolean(value, path);
+    case "string":
+      return validateString(value, path);
+    case "integer":
+      return validateInteger(value, path);
+    case "number":
+      return validateNumber(value, path);
+    case "object":
+      return validateObject(value, schema, path);
+    case "array":
+      return validateArray(value, schema, path);
+    case "map":
+      return validateMap(value, schema, path);
+    default:
+      return {
+        result: false,
+        errorMessage: `Unknown type "${schema.type}" at ${path}`
+      };
+  }
+};
+var validateBoolean = (value, path) => {
+  if (typeof value !== "boolean") {
+    return {
+      result: false,
+      errorMessage: `Expected boolean at ${path}, but got: ${typeof value}`
+    };
+  }
+  return { result: true };
+};
+var validateString = (value, path) => {
+  if (typeof value !== "string") {
+    return {
+      result: false,
+      errorMessage: `Expected string at ${path}, but got: ${typeof value}`
+    };
+  }
+  return { result: true };
+};
+var validateInteger = (value, path) => {
+  if (!Number.isInteger(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected integer at ${path}, but got: ${JSON.stringify(value)}`
+    };
+  }
+  return { result: true };
+};
+var validateNumber = (value, path) => {
+  if (typeof value !== "number" || isNaN(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected number at ${path}, but got: ${JSON.stringify(value)}`
+    };
+  }
+  return { result: true };
+};
+var validateObject = (value, schema, path) => {
+  if (value === null || value === void 0) {
+    return {
+      result: false,
+      errorMessage: `Expected object at ${path}, but got: ${value}`
+    };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected object at ${path}, but got: ${Array.isArray(value) ? "array" : typeof value}`
+    };
+  }
+  const objectValue = value;
+  if (schema.required && schema.required.length > 0) {
+    for (const requiredProperty of schema.required) {
+      if (!(requiredProperty in objectValue)) {
+        return {
+          result: false,
+          errorMessage: `Missing required property "${requiredProperty}" at ${path}`
+        };
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      const isRequired = propertySchema.isPropertyRequired === true;
+      if (isRequired && !(propertyName in objectValue)) {
+        return {
+          result: false,
+          errorMessage: `Missing required property "${propertyName}" at ${path}`
+        };
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      if (propertyName in objectValue) {
+        const propertyPath = isRootPath(path) ? propertyName : `${path}.${propertyName}`;
+        const propertyResult = validateValue(
+          objectValue[propertyName],
+          propertySchema,
+          propertyPath
+        );
+        if (!propertyResult.result) {
+          return propertyResult;
+        }
+      }
+    }
+  }
+  if (schema.additionalProperties) {
+    const definedProperties = new Set(Object.keys(schema.properties || {}));
+    for (const [propertyName, propertyValue] of Object.entries(objectValue)) {
+      if (!definedProperties.has(propertyName)) {
+        const propertyPath = isRootPath(path) ? propertyName : `${path}.${propertyName}`;
+        const propertyResult = validateValue(
+          propertyValue,
+          schema.additionalProperties,
+          propertyPath
+        );
+        if (!propertyResult.result) {
+          return propertyResult;
+        }
+      }
+    }
+  }
+  return { result: true };
+};
+var validateArray = (value, schema, path) => {
+  if (!Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected array at ${path}, but got: ${typeof value}`
+    };
+  }
+  if (schema.items) {
+    for (const [index, item] of value.entries()) {
+      const itemPath = `${path}[${index}]`;
+      const itemResult = validateValue(item, schema.items, itemPath);
+      if (!itemResult.result) {
+        return itemResult;
+      }
+    }
+  }
+  return { result: true };
+};
+var validateMap = (value, schema, path) => {
+  if (value === null || value === void 0) {
+    return {
+      result: false,
+      errorMessage: `Expected map at ${path}, but got: ${value}`
+    };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      result: false,
+      errorMessage: `Expected map at ${path}, but got: ${Array.isArray(value) ? "array" : typeof value}`
+    };
+  }
+  const mapValue = value;
+  if (schema.additionalProperties) {
+    for (const [key, mapItemValue] of Object.entries(mapValue)) {
+      const keyPath = isRootPath(path) ? key : `${path}.${key}`;
+      const keyResult = validateValue(mapItemValue, schema.additionalProperties, keyPath);
+      if (!keyResult.result) {
+        return keyResult;
+      }
+    }
+  }
+  return { result: true };
+};
+var JSONSchemaValidator = (params) => {
+  const { schema, value } = params;
+  try {
+    const validationResult = validateValue(value, schema, ROOT_PATH);
+    return validationResult;
+  } catch (error) {
+    return {
+      result: false,
+      errorMessage: `Validation error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+};
+
+// 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`,
@@ -255,33 +585,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 || 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 (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
@@ -344,67 +740,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
 import { isNil as isNil9 } from "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
   }
 };
 
@@ -413,34 +831,34 @@ import { isNil as isNil3 } from "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 isNil3(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil3(leftValue);
   }
   return false;
@@ -451,10 +869,10 @@ import { isNil as isNil4 } from "lodash-es";
 var conditionObjectHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return isNil4(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil4(leftValue);
   }
   return false;
@@ -465,42 +883,42 @@ import { isNil as isNil5 } from "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 isNil5(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil5(leftValue);
   }
   return false;
@@ -511,13 +929,13 @@ import { isNil as isNil6 } from "lodash-es";
 var conditionNullHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "eq" /* EQ */) {
+  if (operator === ConditionOperation.EQ) {
     return isNil6(leftValue) && isNil6(condition.rightValue);
   }
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return isNil6(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil6(leftValue);
   }
   return false;
@@ -528,32 +946,32 @@ import { isNil as isNil7 } from "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 isNil7(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil7(leftValue);
   }
   return false;
@@ -564,10 +982,10 @@ import { isNil as isNil8 } from "lodash-es";
 var conditionArrayHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === "is_empty" /* IS_EMPTY */) {
+  if (operator === ConditionOperation.IS_EMPTY) {
     return isNil8(leftValue);
   }
-  if (operator === "is_not_empty" /* IS_NOT_EMPTY */) {
+  if (operator === ConditionOperation.IS_NOT_EMPTY) {
     return !isNil8(leftValue);
   }
   return false;
@@ -599,9 +1017,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: {},
@@ -656,16 +1072,55 @@ var WorkflowRuntimeNodeExecutors = [
   EndExecutor,
   LLMExecutor,
   ConditionExecutor,
-  LoopExecutor
+  LoopExecutor,
+  BlockStartExecutor,
+  BlockEndExecutor
 ];
 
 // src/domain/validation/index.ts
 var WorkflowRuntimeValidation = class {
-  validate(schema) {
+  invoke(params) {
+    const { schema, inputs } = params;
+    const schemaValidationResult = this.schema(schema);
+    if (!schemaValidationResult.valid) {
+      return schemaValidationResult;
+    }
+    const inputsValidationResult = this.inputs(this.getWorkflowInputsDeclare(schema), inputs);
+    if (!inputsValidationResult.valid) {
+      return inputsValidationResult;
+    }
+    return {
+      valid: true
+    };
+  }
+  schema(schema) {
     return {
       valid: true
     };
   }
+  inputs(inputsSchema, inputs) {
+    const { result, errorMessage } = JSONSchemaValidator({
+      schema: inputsSchema,
+      value: inputs
+    });
+    if (!result) {
+      const error = `JSON Schema validation failed: ${errorMessage}`;
+      return {
+        valid: false,
+        errors: [error]
+      };
+    }
+    return {
+      valid: true
+    };
+  }
+  getWorkflowInputsDeclare(schema) {
+    const startNode = schema.nodes.find((node) => node.type === FlowGramNode.Start);
+    if (!startNode) {
+      throw new Error("Workflow schema must have a start node");
+    }
+    return startNode.data.outputs;
+  }
 };
 
 // src/domain/executor/index.ts
@@ -690,52 +1145,6 @@ var WorkflowRuntimeExecutor = class {
   }
 };
 
-// src/infrastructure/utils/uuid.ts
-import { v4 } from "uuid";
-var 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) {
@@ -755,6 +1164,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
 import { get, set } from "lodash-es";
 
@@ -1104,7 +1592,7 @@ var WorkflowRuntimeSnapshot = class _WorkflowRuntimeSnapshot {
     this.id = uuid();
     this.data = data;
   }
-  addData(data) {
+  update(data) {
     Object.assign(this.data, data);
   }
   validate() {
@@ -1165,10 +1653,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() {
   }
@@ -1179,7 +1668,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;
   }
@@ -1317,6 +1807,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;
   }
@@ -1554,6 +2050,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) {
@@ -1564,6 +2061,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.ioCenter.init(inputs);
     this.snapshotCenter.init();
     this.statusCenter.init();
+    this.messageCenter.init();
     this.reporter.init();
   }
   dispose() {
@@ -1577,6 +2075,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.ioCenter.dispose();
     this.snapshotCenter.dispose();
     this.statusCenter.dispose();
+    this.messageCenter.dispose();
     this.reporter.dispose();
   }
   sub() {
@@ -1588,6 +2087,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       ioCenter: this.ioCenter,
       snapshotCenter: this.snapshotCenter,
       statusCenter: this.statusCenter,
+      messageCenter: this.messageCenter,
       reporter: this.reporter,
       variableStore,
       state
@@ -1605,7 +2105,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,
@@ -1613,6 +2119,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       ioCenter,
       snapshotCenter,
       statusCenter,
+      messageCenter,
       reporter
     });
   }
@@ -1621,11 +2128,19 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
 // src/domain/engine/index.ts
 var WorkflowRuntimeEngine = class {
   constructor(service) {
+    this.validation = service.Validation;
     this.executor = service.Executor;
   }
   invoke(params) {
     const context = WorkflowRuntimeContext.create();
     context.init(params);
+    const valid = this.validate(params, context);
+    if (!valid) {
+      return WorkflowRuntimeTask.create({
+        processing: Promise.resolve({}),
+        context
+      });
+    }
     const processing = this.process(context);
     processing.then(() => {
       context.dispose();
@@ -1641,11 +2156,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({
@@ -1658,17 +2176,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;
@@ -1680,8 +2204,21 @@ var WorkflowRuntimeEngine = class {
       return outputs;
     } catch (e) {
       context.statusCenter.workflow.fail();
-      throw e;
+      return {};
+    }
+  }
+  validate(params, context) {
+    const { valid, errors } = this.validation.invoke(params);
+    if (valid) {
+      return true;
     }
+    errors?.forEach((message) => {
+      context.messageCenter.error({
+        message
+      });
+    });
+    context.statusCenter.workflow.fail();
+    return false;
   }
   canExecuteNode(params) {
     const { node, context } = params;
@@ -1704,8 +2241,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;
   }
@@ -1748,6 +2288,7 @@ var WorkflowRuntimeContainer = class _WorkflowRuntimeContainer {
     const Validation = new WorkflowRuntimeValidation();
     const Executor = new WorkflowRuntimeExecutor(WorkflowRuntimeNodeExecutors);
     const Engine = new WorkflowRuntimeEngine({
+      Validation,
       Executor
     });
     return {
@@ -1804,6 +2345,12 @@ var WorkflowApplication = class _WorkflowApplication {
     }
     return task.context.ioCenter.outputs;
   }
+  validate(params) {
+    const validation = this.container.get(IValidation);
+    const result = validation.invoke(params);
+    console.log("> POST TaskValidate - valid: ", result.valid);
+    return result;
+  }
   static get instance() {
     if (this._instance) {
       return this._instance;
@@ -1813,6 +2360,19 @@ var WorkflowApplication = class _WorkflowApplication {
   }
 };
 
+// src/api/task-validate.ts
+var TaskValidateAPI = async (input) => {
+  const app = WorkflowApplication.instance;
+  const { schema: stringSchema, inputs } = input;
+  const schema = JSON.parse(stringSchema);
+  const result = app.validate({
+    schema,
+    inputs
+  });
+  const output = result;
+  return output;
+};
+
 // src/api/task-run.ts
 var TaskRunAPI = async (input) => {
   const app = WorkflowApplication.instance;
@@ -1863,22 +2423,21 @@ var TaskCancelAPI = async (input) => {
 
 // src/api/index.ts
 var WorkflowRuntimeAPIs = {
+  [FlowGramAPIName.ServerInfo]: () => {
+  },
+  // TODO
   [FlowGramAPIName.TaskRun]: TaskRunAPI,
   [FlowGramAPIName.TaskReport]: TaskReportAPI,
   [FlowGramAPIName.TaskResult]: TaskResultAPI,
   [FlowGramAPIName.TaskCancel]: TaskCancelAPI,
-  [FlowGramAPIName.ServerInfo]: () => {
-  },
-  // TODO
-  [FlowGramAPIName.Validation]: () => {
-  }
-  // TODO
+  [FlowGramAPIName.TaskValidate]: TaskValidateAPI
 };
 export {
   TaskCancelAPI,
   TaskReportAPI,
   TaskResultAPI,
   TaskRunAPI,
+  TaskValidateAPI,
   WorkflowRuntimeAPIs
 };
 //# sourceMappingURL=index.js.map