@flowgram.ai/runtime-js 0.2.24 → 0.2.26

package/dist/esm/index.js

@@ -304,7 +304,7 @@ var WorkflowRuntimeType;
     const expectedType = types[0];
     types.forEach((type) => {
       if (type !== expectedType) {
-        throw new Error(`array items type must be same, expect ${expectedType}, but got ${type}`);
+        throw new Error(`Array items type must be same, expect ${expectedType}, but got ${type}`);
       }
     });
     return expectedType;
@@ -462,8 +462,8 @@ var validateObject = (value, schema, path) => {
     }
   }
   if (schema.properties) {
-    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
-      const isRequired = propertySchema.isPropertyRequired === true;
+    for (const [propertyName] of Object.entries(schema.properties)) {
+      const isRequired = schema.required?.includes(propertyName) ?? false;
       if (isRequired && !(propertyName in objectValue)) {
         return {
           result: false,
@@ -573,7 +573,7 @@ var LoopExecutor = class {
     const subNodes = context.node.children;
     const blockStartNode = subNodes.find((node) => node.type === FlowGramNode.BlockStart);
     if (!blockStartNode) {
-      throw new Error("block start node not found");
+      throw new Error("Loop block start node not found");
     }
     const blockOutputs = [];
     for (let index = 0; index < loopArray.length; index++) {
@@ -591,10 +591,14 @@ var LoopExecutor = class {
         type: WorkflowVariableType.Number,
         value: index
       });
-      await engine.executeNode({
-        context: subContext,
-        node: blockStartNode
-      });
+      try {
+        await engine.executeNode({
+          context: subContext,
+          node: blockStartNode
+        });
+      } catch (e) {
+        throw new Error(`Loop block execute error`);
+      }
       const blockOutput = this.getBlockOutput(context, subContext);
       blockOutputs.push(blockOutput);
     }
@@ -615,15 +619,15 @@ var LoopExecutor = class {
   checkLoopArray(LoopArrayVariable) {
     const loopArray = LoopArrayVariable?.value;
     if (!loopArray || isNil(loopArray) || !Array.isArray(loopArray)) {
-      throw new Error("loopFor is required");
+      throw new Error('Loop "loopFor" is required');
     }
     const loopArrayType = LoopArrayVariable.type;
     if (loopArrayType !== WorkflowVariableType.Array) {
-      throw new Error("loopFor must be an array");
+      throw new Error('Loop "loopFor" must be an array');
     }
     const loopArrayItemType = LoopArrayVariable.itemsType;
     if (isNil(loopArrayItemType)) {
-      throw new Error("loopFor items must be array items");
+      throw new Error('Loop "loopFor.items" must be array items');
     }
   }
   getBlockOutput(executionContext, subContext) {
@@ -684,13 +688,63 @@ var LoopExecutor = class {
 import { isNil as isNil2 } from "lodash-es";
 import { ChatOpenAI } from "@langchain/openai";
 import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+
+// src/nodes/llm/api-validator.ts
+var APIValidator;
+((APIValidator2) => {
+  APIValidator2.isValidFormat = (apiHost) => {
+    if (!apiHost || typeof apiHost !== "string") {
+      return false;
+    }
+    try {
+      const url = new URL(apiHost);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch (error) {
+      return false;
+    }
+  };
+  APIValidator2.isExist = async (apiHost) => {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      await fetch(apiHost, {
+        method: "HEAD",
+        // Use HEAD to minimize data transfer
+        signal: controller.signal,
+        // Disable following redirects to get the actual host response
+        redirect: "manual"
+      });
+      clearTimeout(timeoutId);
+      return true;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        return false;
+      }
+      const errorMessage = error.message?.toLowerCase() || "";
+      const networkFailurePatterns = [
+        "network error",
+        "connection refused",
+        "dns",
+        "resolve",
+        "timeout",
+        "unreachable"
+      ];
+      const isNetworkFailure = networkFailurePatterns.some(
+        (pattern) => errorMessage.includes(pattern)
+      );
+      return !isNetworkFailure;
+    }
+  };
+})(APIValidator || (APIValidator = {}));
+
+// src/nodes/llm/index.ts
 var LLMExecutor = class {
   constructor() {
     this.type = FlowGramNode.LLM;
   }
   async execute(context) {
     const inputs = context.inputs;
-    this.checkInputs(inputs);
+    await this.checkInputs(inputs);
     const { modelName, temperature, apiKey, apiHost, systemPrompt, prompt } = inputs;
     const model = new ChatOpenAI({
       modelName,
@@ -705,7 +759,16 @@ var LLMExecutor = class {
       messages.push(new SystemMessage(systemPrompt));
     }
     messages.push(new HumanMessage(prompt));
-    const apiMessage = await model.invoke(messages);
+    let apiMessage;
+    try {
+      apiMessage = await model.invoke(messages);
+    } catch (error) {
+      const errorMessage = error?.message;
+      if (errorMessage === "Connection error.") {
+        throw new Error(`Network error: unreachable api "${apiHost}"`);
+      }
+      throw error;
+    }
     const result = apiMessage.content;
     return {
       outputs: {
@@ -713,16 +776,23 @@ var LLMExecutor = class {
       }
     };
   }
-  checkInputs(inputs) {
+  async checkInputs(inputs) {
     const { modelName, temperature, apiKey, apiHost, prompt } = inputs;
     const missingInputs = [];
-    if (isNil2(modelName)) missingInputs.push("modelName");
+    if (!modelName) missingInputs.push("modelName");
     if (isNil2(temperature)) missingInputs.push("temperature");
-    if (isNil2(apiKey)) missingInputs.push("apiKey");
-    if (isNil2(apiHost)) missingInputs.push("apiHost");
-    if (isNil2(prompt)) missingInputs.push("prompt");
+    if (!apiKey) missingInputs.push("apiKey");
+    if (!apiHost) missingInputs.push("apiHost");
+    if (!prompt) missingInputs.push("prompt");
     if (missingInputs.length > 0) {
-      throw new Error(`LLM node missing required inputs: ${missingInputs.join(", ")}`);
+      throw new Error(`LLM node missing required inputs: "${missingInputs.join('", "')}"`);
+    }
+    if (!APIValidator.isValidFormat(apiHost)) {
+      throw new Error(`Invalid API host format - ${apiHost}`);
+    }
+    const apiHostExists = await APIValidator.isExist(apiHost);
+    if (!apiHostExists) {
+      throw new Error(`Unreachable API host - ${apiHost}`);
     }
   }
 };
@@ -1017,7 +1087,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) {
-      throw new Error("no condition is activated");
+      throw new Error("No condition is activated");
     }
     return {
       outputs: {},
@@ -1045,11 +1115,13 @@ var ConditionExecutor = class {
   checkCondition(condition) {
     const rule = conditionRules[condition.leftType];
     if (isNil9(rule)) {
-      throw new Error(`condition left type ${condition.leftType} is not supported`);
+      throw new Error(`Condition left type "${condition.leftType}" is not supported`);
     }
     const ruleType = rule[condition.operator];
     if (isNil9(ruleType)) {
-      throw new Error(`condition operator ${condition.operator} is not supported`);
+      throw new Error(
+        `Condition left type "${condition.leftType}" has no operator "${condition.operator}"`
+      );
     }
     if (ruleType !== condition.rightType) {
       return false;
@@ -1059,7 +1131,7 @@ var ConditionExecutor = class {
   handleCondition(condition) {
     const handler = conditionHandlers[condition.leftType];
     if (!handler) {
-      throw new Error(`condition left type ${condition.leftType} is not supported`);
+      throw new Error(`Condition left type ${condition.leftType} is not supported`);
     }
     const isActive = handler(condition);
     return isActive;
@@ -1077,6 +1149,241 @@ var WorkflowRuntimeNodeExecutors = [
   BlockEndExecutor
 ];
 
+// src/domain/validation/validators/cycle-detection.ts
+var cycleDetection = (schema) => {
+  const { nodes, edges } = schema;
+  const adjacencyList = /* @__PURE__ */ new Map();
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  nodeIds.forEach((nodeId) => {
+    adjacencyList.set(nodeId, []);
+  });
+  edges.forEach((edge) => {
+    const sourceList = adjacencyList.get(edge.sourceNodeID);
+    if (sourceList) {
+      sourceList.push(edge.targetNodeID);
+    }
+  });
+  let NodeStatus;
+  ((NodeStatus2) => {
+    NodeStatus2[NodeStatus2["Unvisited"] = 0] = "Unvisited";
+    NodeStatus2[NodeStatus2["Visiting"] = 1] = "Visiting";
+    NodeStatus2[NodeStatus2["Visited"] = 2] = "Visited";
+  })(NodeStatus || (NodeStatus = {}));
+  const nodeStatusMap = /* @__PURE__ */ new Map();
+  nodeIds.forEach((nodeId) => {
+    nodeStatusMap.set(nodeId, 0 /* Unvisited */);
+  });
+  const detectCycleFromNode = (nodeId) => {
+    nodeStatusMap.set(nodeId, 1 /* Visiting */);
+    const neighbors = adjacencyList.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      const neighborColor = nodeStatusMap.get(neighbor);
+      if (neighborColor === 1 /* Visiting */) {
+        return true;
+      }
+      if (neighborColor === 0 /* Unvisited */ && detectCycleFromNode(neighbor)) {
+        return true;
+      }
+    }
+    nodeStatusMap.set(nodeId, 2 /* Visited */);
+    return false;
+  };
+  for (const nodeId of nodeIds) {
+    if (nodeStatusMap.get(nodeId) === 0 /* Unvisited */) {
+      if (detectCycleFromNode(nodeId)) {
+        throw new Error("Workflow schema contains a cycle, which is not allowed");
+      }
+    }
+  }
+  nodes.forEach((node) => {
+    if (node.blocks) {
+      cycleDetection({
+        nodes: node.blocks,
+        edges: node.edges ?? []
+      });
+    }
+  });
+};
+
+// src/domain/validation/validators/start-end-node.ts
+var blockStartEndNode = (schema) => {
+  const { blockStartNodes, blockEndNodes } = schema.nodes.reduce(
+    (acc, node) => {
+      if (node.type === FlowGramNode.BlockStart) {
+        acc.blockStartNodes.push(node);
+      } else if (node.type === FlowGramNode.BlockEnd) {
+        acc.blockEndNodes.push(node);
+      }
+      return acc;
+    },
+    { blockStartNodes: [], blockEndNodes: [] }
+  );
+  if (!blockStartNodes.length && !blockEndNodes.length) {
+    throw new Error("Workflow block schema must have a block-start node and a block-end node");
+  }
+  if (!blockStartNodes.length) {
+    throw new Error("Workflow block schema must have a block-start node");
+  }
+  if (!blockEndNodes.length) {
+    throw new Error("Workflow block schema must have an block-end node");
+  }
+  if (blockStartNodes.length > 1) {
+    throw new Error("Workflow block schema must have only one block-start node");
+  }
+  if (blockEndNodes.length > 1) {
+    throw new Error("Workflow block schema must have only one block-end node");
+  }
+  schema.nodes.forEach((node) => {
+    if (node.blocks) {
+      blockStartEndNode({
+        nodes: node.blocks,
+        edges: node.edges ?? []
+      });
+    }
+  });
+};
+var startEndNode = (schema) => {
+  const { startNodes, endNodes } = schema.nodes.reduce(
+    (acc, node) => {
+      if (node.type === FlowGramNode.Start) {
+        acc.startNodes.push(node);
+      } else if (node.type === FlowGramNode.End) {
+        acc.endNodes.push(node);
+      }
+      return acc;
+    },
+    { startNodes: [], endNodes: [] }
+  );
+  if (!startNodes.length && !endNodes.length) {
+    throw new Error("Workflow schema must have a start node and an end node");
+  }
+  if (!startNodes.length) {
+    throw new Error("Workflow schema must have a start node");
+  }
+  if (!endNodes.length) {
+    throw new Error("Workflow schema must have an end node");
+  }
+  if (startNodes.length > 1) {
+    throw new Error("Workflow schema must have only one start node");
+  }
+  if (endNodes.length > 1) {
+    throw new Error("Workflow schema must have only one end node");
+  }
+  schema.nodes.forEach((node) => {
+    if (node.blocks) {
+      blockStartEndNode({
+        nodes: node.blocks,
+        edges: node.edges ?? []
+      });
+    }
+  });
+};
+
+// src/domain/validation/validators/edge-source-target-exist.ts
+var edgeSourceTargetExist = (schema) => {
+  const { nodes, edges } = schema;
+  const nodeSet = new Set(nodes.map((node) => node.id));
+  edges.forEach((edge) => {
+    if (!nodeSet.has(edge.sourceNodeID)) {
+      throw new Error(`Workflow schema edge source node "${edge.sourceNodeID}" not exist`);
+    }
+    if (!nodeSet.has(edge.targetNodeID)) {
+      throw new Error(`Workflow schema edge target node "${edge.targetNodeID}" not exist`);
+    }
+  });
+  nodes.forEach((node) => {
+    if (node.blocks) {
+      edgeSourceTargetExist({
+        nodes: node.blocks,
+        edges: node.edges ?? []
+      });
+    }
+  });
+};
+
+// src/domain/validation/validators/schema-format.ts
+var schemaFormat = (schema) => {
+  if (!schema || typeof schema !== "object") {
+    throw new Error("Workflow schema must be a valid object");
+  }
+  if (!Array.isArray(schema.nodes)) {
+    throw new Error("Workflow schema must have a valid nodes array");
+  }
+  if (!Array.isArray(schema.edges)) {
+    throw new Error("Workflow schema must have a valid edges array");
+  }
+  schema.nodes.forEach((node, index) => {
+    validateNodeFormat(node, `nodes[${index}]`);
+  });
+  schema.edges.forEach((edge, index) => {
+    validateEdgeFormat(edge, `edges[${index}]`);
+  });
+  schema.nodes.forEach((node, nodeIndex) => {
+    if (node.blocks) {
+      if (!Array.isArray(node.blocks)) {
+        throw new Error(`Node nodes[${nodeIndex}].blocks must be an array`);
+      }
+      const nestedSchema = {
+        nodes: node.blocks,
+        edges: node.edges || []
+      };
+      schemaFormat(nestedSchema);
+    }
+  });
+};
+var validateNodeFormat = (node, path) => {
+  if (!node || typeof node !== "object") {
+    throw new Error(`${path} must be a valid object`);
+  }
+  if (typeof node.id !== "string" || !node.id.trim()) {
+    throw new Error(`${path}.id must be a non-empty string`);
+  }
+  if (typeof node.type !== "string" || !node.type.trim()) {
+    throw new Error(`${path}.type must be a non-empty string`);
+  }
+  if (!node.meta || typeof node.meta !== "object") {
+    throw new Error(`${path}.meta must be a valid object`);
+  }
+  if (!node.data || typeof node.data !== "object") {
+    throw new Error(`${path}.data must be a valid object`);
+  }
+  if (node.blocks !== void 0 && !Array.isArray(node.blocks)) {
+    throw new Error(`${path}.blocks must be an array if present`);
+  }
+  if (node.edges !== void 0 && !Array.isArray(node.edges)) {
+    throw new Error(`${path}.edges must be an array if present`);
+  }
+  if (node.data.inputs !== void 0 && (typeof node.data.inputs !== "object" || node.data.inputs === null)) {
+    throw new Error(`${path}.data.inputs must be a valid object if present`);
+  }
+  if (node.data.outputs !== void 0 && (typeof node.data.outputs !== "object" || node.data.outputs === null)) {
+    throw new Error(`${path}.data.outputs must be a valid object if present`);
+  }
+  if (node.data.inputsValues !== void 0 && (typeof node.data.inputsValues !== "object" || node.data.inputsValues === null)) {
+    throw new Error(`${path}.data.inputsValues must be a valid object if present`);
+  }
+  if (node.data.title !== void 0 && typeof node.data.title !== "string") {
+    throw new Error(`${path}.data.title must be a string if present`);
+  }
+};
+var validateEdgeFormat = (edge, path) => {
+  if (!edge || typeof edge !== "object") {
+    throw new Error(`${path} must be a valid object`);
+  }
+  if (typeof edge.sourceNodeID !== "string" || !edge.sourceNodeID.trim()) {
+    throw new Error(`${path}.sourceNodeID must be a non-empty string`);
+  }
+  if (typeof edge.targetNodeID !== "string" || !edge.targetNodeID.trim()) {
+    throw new Error(`${path}.targetNodeID must be a non-empty string`);
+  }
+  if (edge.sourcePortID !== void 0 && typeof edge.sourcePortID !== "string") {
+    throw new Error(`${path}.sourcePortID must be a string if present`);
+  }
+  if (edge.targetPortID !== void 0 && typeof edge.targetPortID !== "string") {
+    throw new Error(`${path}.targetPortID must be a string if present`);
+  }
+};
+
 // src/domain/validation/index.ts
 var WorkflowRuntimeValidation = class {
   invoke(params) {
@@ -1094,8 +1401,23 @@ var WorkflowRuntimeValidation = class {
     };
   }
   schema(schema) {
+    const errors = [];
+    const validations = [
+      () => schemaFormat(schema),
+      () => cycleDetection(schema),
+      () => edgeSourceTargetExist(schema),
+      () => startEndNode(schema)
+    ];
+    validations.forEach((validation) => {
+      try {
+        validation();
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    });
     return {
-      valid: true
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
     };
   }
   inputs(inputsSchema, inputs) {
@@ -1138,7 +1460,7 @@ var WorkflowRuntimeExecutor = class {
     const nodeType = context.node.type;
     const nodeExecutor = this.nodeExecutors.get(nodeType);
     if (!nodeExecutor) {
-      throw new Error(`no executor found for node type ${nodeType}`);
+      throw new Error(`No executor found for node type ${nodeType}`);
     }
     const output = await nodeExecutor.execute(context);
     return output;
@@ -1513,7 +1835,7 @@ var WorkflowRuntimeState = class {
   }
   parseRef(ref) {
     if (ref?.type !== "ref") {
-      throw new Error(`invalid ref value: ${ref}`);
+      throw new Error(`Invalid ref value: ${ref}`);
     }
     if (!ref.content || ref.content.length < 2) {
       return null;
@@ -1531,7 +1853,7 @@ var WorkflowRuntimeState = class {
   }
   parseTemplate(template) {
     if (template?.type !== "template") {
-      throw new Error(`invalid template value: ${template}`);
+      throw new Error(`Invalid template value: ${template}`);
     }
     if (!template.content) {
       return null;
@@ -1557,7 +1879,7 @@ var WorkflowRuntimeState = class {
   }
   parseValue(flowValue) {
     if (!flowValue?.type) {
-      throw new Error(`invalid flow value type: ${flowValue.type}`);
+      throw new Error(`Invalid flow value type: ${flowValue.type}`);
     }
     if (flowValue.type === "constant") {
       const value = flowValue.content;
@@ -1576,7 +1898,7 @@ var WorkflowRuntimeState = class {
     if (flowValue.type === "template") {
       return this.parseTemplate(flowValue);
     }
-    throw new Error(`unknown flow value type: ${flowValue.type}`);
+    throw new Error(`Unknown flow value type: ${flowValue.type}`);
   }
   isExecutedNode(node) {
     return this.executedNodes.has(node.id);
@@ -1961,7 +2283,7 @@ var createStore = (params) => {
     const from = store.nodes.get(sourceNodeID);
     const to = store.nodes.get(targetNodeID);
     if (!from || !to) {
-      throw new Error(`invalid edge schema ID: ${id}, from: ${sourceNodeID}, to: ${targetNodeID}`);
+      throw new Error(`Invalid edge schema ID: ${id}, from: ${sourceNodeID}, to: ${targetNodeID}`);
     }
     const edge = createEdge(store, {
       id,
@@ -2236,7 +2558,7 @@ var WorkflowRuntimeEngine = class {
     }
     const targetPort = node.ports.outputs.find((port) => port.id === branch);
     if (!targetPort) {
-      throw new Error(`branch ${branch} not found`);
+      throw new Error(`Engine branch ${branch} not found`);
     }
     const nextNodeIDs = new Set(targetPort.edges.map((edge) => edge.to.id));
     const nextNodes = allNextNodes.filter((nextNode) => nextNodeIDs.has(nextNode.id));
@@ -2251,11 +2573,11 @@ var WorkflowRuntimeEngine = class {
   }
   async executeNext(params) {
     const { context, node, nextNodes } = params;
-    if (node.type === FlowGramNode.End) {
+    if (node.type === FlowGramNode.End || node.type === FlowGramNode.BlockEnd) {
       return;
     }
     if (nextNodes.length === 0) {
-      return;
+      throw new Error(`Node ${node.id} has no next nodes`);
     }
     await Promise.all(
       nextNodes.map(