@flowgram.ai/runtime-js 0.2.27 → 0.2.28

package/dist/index.js

@@ -236,13 +236,16 @@ var FlowGramNode = /* @__PURE__ */ ((FlowGramNode22) => {
   FlowGramNode22["Start"] = "start";
   FlowGramNode22["End"] = "end";
   FlowGramNode22["LLM"] = "llm";
-  FlowGramNode22["code"] = "code";
+  FlowGramNode22["Code"] = "code";
   FlowGramNode22["Condition"] = "condition";
   FlowGramNode22["Loop"] = "loop";
   FlowGramNode22["Comment"] = "comment";
   FlowGramNode22["Group"] = "group";
   FlowGramNode22["BlockStart"] = "block-start";
   FlowGramNode22["BlockEnd"] = "block-end";
+  FlowGramNode22["HTTP"] = "http";
+  FlowGramNode22["Break"] = "break";
+  FlowGramNode22["Continue"] = "continue";
   return FlowGramNode22;
 })(FlowGramNode || {});
 var ConditionOperation = /* @__PURE__ */ ((ConditionOperation2) => {
@@ -262,6 +265,15 @@ var ConditionOperation = /* @__PURE__ */ ((ConditionOperation2) => {
   ConditionOperation2["IS_FALSE"] = "is_false";
   return ConditionOperation2;
 })(ConditionOperation || {});
+var HTTPBodyType = /* @__PURE__ */ ((HTTPBodyType2) => {
+  HTTPBodyType2["None"] = "none";
+  HTTPBodyType2["FormData"] = "form-data";
+  HTTPBodyType2["XWwwFormUrlencoded"] = "x-www-form-urlencoded";
+  HTTPBodyType2["RawText"] = "raw-text";
+  HTTPBodyType2["JSON"] = "JSON";
+  HTTPBodyType2["Binary"] = "binary";
+  return HTTPBodyType2;
+})(HTTPBodyType || {});
 var IEngine = Symbol.for("Engine");
 var IExecutor = Symbol.for("Executor");
 var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
@@ -640,6 +652,12 @@ var LoopExecutor = class {
       } catch (e) {
         throw new Error(`Loop block execute error`);
       }
+      if (this.isBreak(subContext)) {
+        break;
+      }
+      if (this.isContinue(subContext)) {
+        continue;
+      }
       const blockOutput = this.getBlockOutput(context, subContext);
       blockOutputs.push(blockOutput);
     }
@@ -723,6 +741,12 @@ var LoopExecutor = class {
     const loopOutputsDeclare = loopNodeData.loopOutputs ?? {};
     return loopOutputsDeclare;
   }
+  isBreak(subContext) {
+    return subContext.cache.get("loop-break") === true;
+  }
+  isContinue(subContext) {
+    return subContext.cache.get("loop-continue") === true;
+  }
 };
 
 // src/nodes/llm/index.ts
@@ -792,6 +816,227 @@ var LLMExecutor = class {
   }
 };
 
+// src/nodes/http/index.ts
+var HTTPExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.HTTP;
+  }
+  async execute(context) {
+    const inputs = this.parseInputs(context);
+    const response = await this.request(inputs);
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    const responseBody = await response.text();
+    return {
+      outputs: {
+        headers: responseHeaders,
+        statusCode: response.status,
+        body: responseBody
+      }
+    };
+  }
+  async request(inputs) {
+    const { method, url, headers, params, bodyType, body, retryTimes, timeout } = inputs;
+    const urlWithParams = this.buildUrlWithParams(url, params);
+    const requestOptions = {
+      method,
+      headers: this.prepareHeaders(headers, bodyType),
+      signal: AbortSignal.timeout(timeout)
+    };
+    if (method !== "GET" && method !== "HEAD" && body) {
+      requestOptions.body = this.prepareBody(body, bodyType);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= retryTimes; attempt++) {
+      try {
+        const response = await fetch(urlWithParams, requestOptions);
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (attempt < retryTimes) {
+          await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+        }
+      }
+    }
+    throw lastError || new Error("HTTP request failed after all retry attempts");
+  }
+  parseInputs(context) {
+    const httpNode = context.node;
+    const method = httpNode.data.api.method;
+    const urlVariable = context.runtime.state.parseTemplate(httpNode.data.api.url);
+    if (!urlVariable) {
+      throw new Error("HTTP url is required");
+    }
+    const url = urlVariable.value;
+    const headers = context.runtime.state.parseInputs({
+      values: httpNode.data.headersValues,
+      declare: httpNode.data.headers
+    });
+    const params = context.runtime.state.parseInputs({
+      values: httpNode.data.paramsValues,
+      declare: httpNode.data.params
+    });
+    const body = this.parseBody(context);
+    const retryTimes = httpNode.data.timeout.retryTimes;
+    const timeout = httpNode.data.timeout.timeout;
+    const inputs = {
+      method,
+      url,
+      headers,
+      params,
+      bodyType: body.bodyType,
+      body: body.body,
+      retryTimes,
+      timeout
+    };
+    context.snapshot.update({
+      inputs: JSON.parse(JSON.stringify(inputs))
+    });
+    return inputs;
+  }
+  parseBody(context) {
+    const httpNode = context.node;
+    const bodyType = httpNode.data.body.bodyType;
+    if (bodyType === HTTPBodyType.None) {
+      return {
+        bodyType,
+        body: ""
+      };
+    }
+    if (bodyType === HTTPBodyType.JSON) {
+      if (!httpNode.data.body.json) {
+        throw new Error("HTTP json body is required");
+      }
+      const jsonVariable = context.runtime.state.parseTemplate(httpNode.data.body.json);
+      if (!jsonVariable) {
+        throw new Error("HTTP json body is required");
+      }
+      return {
+        bodyType,
+        body: jsonVariable.value
+      };
+    }
+    if (bodyType === HTTPBodyType.FormData) {
+      if (!httpNode.data.body.formData || !httpNode.data.body.formDataValues) {
+        throw new Error("HTTP form-data body is required");
+      }
+      const formData = context.runtime.state.parseInputs({
+        values: httpNode.data.body.formDataValues,
+        declare: httpNode.data.body.formData
+      });
+      return {
+        bodyType,
+        body: JSON.stringify(formData)
+      };
+    }
+    if (bodyType === HTTPBodyType.RawText) {
+      if (!httpNode.data.body.json) {
+        throw new Error("HTTP json body is required");
+      }
+      const jsonVariable = context.runtime.state.parseTemplate(httpNode.data.body.json);
+      if (!jsonVariable) {
+        throw new Error("HTTP json body is required");
+      }
+      return {
+        bodyType,
+        body: jsonVariable.value
+      };
+    }
+    if (bodyType === HTTPBodyType.Binary) {
+      if (!httpNode.data.body.binary) {
+        throw new Error("HTTP binary body is required");
+      }
+      const binaryVariable = context.runtime.state.parseTemplate(httpNode.data.body.binary);
+      if (!binaryVariable) {
+        throw new Error("HTTP binary body is required");
+      }
+      return {
+        bodyType,
+        body: binaryVariable.value
+      };
+    }
+    if (bodyType === HTTPBodyType.XWwwFormUrlencoded) {
+      if (!httpNode.data.body.xWwwFormUrlencoded || !httpNode.data.body.xWwwFormUrlencodedValues) {
+        throw new Error("HTTP x-www-form-urlencoded body is required");
+      }
+      const xWwwFormUrlencoded = context.runtime.state.parseInputs({
+        values: httpNode.data.body.xWwwFormUrlencodedValues,
+        declare: httpNode.data.body.xWwwFormUrlencoded
+      });
+      return {
+        bodyType,
+        body: JSON.stringify(xWwwFormUrlencoded)
+      };
+    }
+    throw new Error(`HTTP invalid body type "${bodyType}"`);
+  }
+  buildUrlWithParams(url, params) {
+    const urlObj = new URL(url);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null && value !== "") {
+        urlObj.searchParams.set(key, value);
+      }
+    });
+    return urlObj.toString();
+  }
+  prepareHeaders(headers, bodyType) {
+    const preparedHeaders = { ...headers };
+    if (!preparedHeaders["Content-Type"] && !preparedHeaders["content-type"]) {
+      switch (bodyType) {
+        case HTTPBodyType.JSON:
+          preparedHeaders["Content-Type"] = "application/json";
+          break;
+        case HTTPBodyType.FormData:
+          break;
+        case HTTPBodyType.XWwwFormUrlencoded:
+          preparedHeaders["Content-Type"] = "application/x-www-form-urlencoded";
+          break;
+        case HTTPBodyType.RawText:
+          preparedHeaders["Content-Type"] = "text/plain";
+          break;
+        case HTTPBodyType.Binary:
+          preparedHeaders["Content-Type"] = "application/octet-stream";
+          break;
+      }
+    }
+    return preparedHeaders;
+  }
+  prepareBody(body, bodyType) {
+    switch (bodyType) {
+      case HTTPBodyType.JSON:
+        return body;
+      case HTTPBodyType.FormData:
+        const formData = new FormData();
+        try {
+          const data = JSON.parse(body);
+          Object.entries(data).forEach(([key, value]) => {
+            formData.append(key, String(value));
+          });
+        } catch (error) {
+          throw new Error("Invalid FormData body format");
+        }
+        return formData;
+      case HTTPBodyType.XWwwFormUrlencoded:
+        try {
+          const data = JSON.parse(body);
+          const params = new URLSearchParams();
+          Object.entries(data).forEach(([key, value]) => {
+            params.append(key, String(value));
+          });
+          return params.toString();
+        } catch (error) {
+          throw new Error("Invalid x-www-form-urlencoded body format");
+        }
+      case HTTPBodyType.RawText:
+      case HTTPBodyType.Binary:
+      default:
+        return body;
+    }
+  }
+};
+
 // src/nodes/end/index.ts
 var EndExecutor = class {
   constructor() {
@@ -827,6 +1072,19 @@ var BlockEndExecutor = class {
   }
 };
 
+// src/nodes/continue/index.ts
+var ContinueExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.Continue;
+  }
+  async execute(context) {
+    context.runtime.cache.set("loop-continue", true);
+    return {
+      outputs: {}
+    };
+  }
+};
+
 // src/nodes/condition/index.ts
 var import_lodash_es9 = require("lodash-es");
 
@@ -1118,7 +1376,7 @@ var ConditionExecutor = class {
         `Condition left type "${condition.leftType}" has no operator "${condition.operator}"`
       );
     }
-    if (ruleType !== condition.rightType) {
+    if (!WorkflowRuntimeType.isTypeEqual(ruleType, condition.rightType)) {
       return false;
     }
     return true;
@@ -1133,6 +1391,81 @@ var ConditionExecutor = class {
   }
 };
 
+// src/nodes/code/index.ts
+var CodeExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.Code;
+  }
+  async execute(context) {
+    const inputs = this.parseInputs(context);
+    if (inputs.script.language === "javascript") {
+      return this.javascript(inputs);
+    }
+    throw new Error(`Unsupported code language "${inputs.script.language}"`);
+  }
+  parseInputs(context) {
+    const codeNode = context.node;
+    const params = context.inputs;
+    const { language, content } = codeNode.data.script;
+    if (!content) {
+      throw new Error("Code content is required");
+    }
+    return {
+      params,
+      script: {
+        language,
+        content
+      }
+    };
+  }
+  async javascript(inputs) {
+    const { params = {}, script } = inputs;
+    try {
+      const executeCode = new Function(
+        "params",
+        `
+        'use strict';
+
+        ${script.content}
+
+        // Ensure main function exists
+        if (typeof main !== 'function') {
+          throw new Error('main function is required in the script');
+        }
+
+        // Execute main function with params
+        return main({ params });
+        `
+      );
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error("Code execution timeout: exceeded 1 minute"));
+        }, 1e3 * 60);
+      });
+      const result = await Promise.race([executeCode(params), timeoutPromise]);
+      const outputs = result && typeof result === "object" && !Array.isArray(result) ? result : { result };
+      return {
+        outputs
+      };
+    } catch (error) {
+      throw new Error(`Code execution failed: ${error.message}`);
+    }
+  }
+};
+
+// src/nodes/break/index.ts
+var BreakExecutor = class {
+  constructor() {
+    this.type = FlowGramNode.Break;
+  }
+  async execute(context) {
+    context.runtime.cache.set("loop-break", true);
+    return {
+      outputs: {}
+    };
+  }
+};
+
 // src/nodes/index.ts
 var WorkflowRuntimeNodeExecutors = [
   StartExecutor,
@@ -1141,7 +1474,11 @@ var WorkflowRuntimeNodeExecutors = [
   ConditionExecutor,
   LoopExecutor,
   BlockStartExecutor,
-  BlockEndExecutor
+  BlockEndExecutor,
+  HTTPExecutor,
+  CodeExecutor,
+  BreakExecutor,
+  ContinueExecutor
 ];
 
 // src/domain/validation/validators/cycle-detection.ts
@@ -1560,6 +1897,29 @@ var WorkflowRuntimeMessageCenter = class {
   }
 };
 
+// src/domain/cache/index.ts
+var WorkflowRuntimeCache = class {
+  init() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  dispose() {
+    this.map.clear();
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    this.map.set(key, value);
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+};
+
 // src/domain/variable/variable-store/index.ts
 var import_lodash_es10 = require("lodash-es");
 
@@ -1785,26 +2145,10 @@ var WorkflowRuntimeState = class {
   getNodeInputs(node) {
     const inputsDeclare = node.declare.inputs;
     const inputsValues = node.declare.inputsValues;
-    if (!inputsDeclare || !inputsValues) {
-      return {};
-    }
-    return Object.entries(inputsValues).reduce((prev, [key, inputValue]) => {
-      const typeInfo = inputsDeclare.properties?.[key];
-      if (!typeInfo) {
-        return prev;
-      }
-      const expectType = typeInfo.type;
-      const result = this.parseValue(inputValue);
-      if (!result) {
-        return prev;
-      }
-      const { value, type } = result;
-      if (!WorkflowRuntimeType.isTypeEqual(type, expectType)) {
-        return prev;
-      }
-      prev[key] = value;
-      return prev;
-    }, {});
+    return this.parseInputs({
+      values: inputsValues,
+      declare: inputsDeclare
+    });
   }
   setNodeOutputs(params) {
     const { node, outputs } = params;
@@ -1828,6 +2172,29 @@ var WorkflowRuntimeState = class {
       });
     });
   }
+  parseInputs(params) {
+    const { values, declare } = params;
+    if (!declare || !values) {
+      return {};
+    }
+    return Object.entries(values).reduce((prev, [key, inputValue]) => {
+      const typeInfo = declare.properties?.[key];
+      if (!typeInfo) {
+        return prev;
+      }
+      const expectType = typeInfo.type;
+      const result = this.parseValue(inputValue);
+      if (!result) {
+        return prev;
+      }
+      const { value, type } = result;
+      if (!WorkflowRuntimeType.isTypeEqual(type, expectType)) {
+        return prev;
+      }
+      prev[key] = value;
+      return prev;
+    }, {});
+  }
   parseRef(ref) {
     if (ref?.type !== "ref") {
       throw new Error(`Invalid ref value: ${ref}`);
@@ -2361,6 +2728,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
   constructor(data) {
     this.subContexts = [];
     this.id = uuid();
+    this.cache = data.cache;
     this.document = data.document;
     this.variableStore = data.variableStore;
     this.state = data.state;
@@ -2372,6 +2740,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
   }
   init(params) {
     const { schema, inputs } = params;
+    this.cache.init();
     this.document.init(schema);
     this.variableStore.init();
     this.state.init();
@@ -2386,6 +2755,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       subContext.dispose();
     });
     this.subContexts = [];
+    this.cache.dispose();
     this.document.dispose();
     this.variableStore.dispose();
     this.state.dispose();
@@ -2396,10 +2766,12 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.reporter.dispose();
   }
   sub() {
+    const cache = new WorkflowRuntimeCache();
     const variableStore = new WorkflowRuntimeVariableStore();
     variableStore.setParent(this.variableStore);
     const state = new WorkflowRuntimeState(variableStore);
     const contextData = {
+      cache,
       document: this.document,
       ioCenter: this.ioCenter,
       snapshotCenter: this.snapshotCenter,
@@ -2411,11 +2783,13 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     };
     const subContext = new _WorkflowRuntimeContext(contextData);
     this.subContexts.push(subContext);
+    subContext.cache.init();
     subContext.variableStore.init();
     subContext.state.init();
     return subContext;
   }
   static create() {
+    const cache = new WorkflowRuntimeCache();
     const document = new WorkflowRuntimeDocument();
     const variableStore = new WorkflowRuntimeVariableStore();
     const state = new WorkflowRuntimeState(variableStore);
@@ -2430,6 +2804,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
       messageCenter
     );
     return new _WorkflowRuntimeContext({
+      cache,
       document,
       variableStore,
       state,
@@ -2487,7 +2862,8 @@ var WorkflowRuntimeEngine = class {
         node,
         inputs,
         runtime: context,
-        container: WorkflowRuntimeContainer.instance
+        container: WorkflowRuntimeContainer.instance,
+        snapshot
       });
       if (context.statusCenter.workflow.terminated) {
         return;
@@ -2568,7 +2944,13 @@ var WorkflowRuntimeEngine = class {
   }
   async executeNext(params) {
     const { context, node, nextNodes } = params;
-    if (node.type === FlowGramNode.End || node.type === FlowGramNode.BlockEnd) {
+    const terminatingNodeTypes = [
+      FlowGramNode.End,
+      FlowGramNode.BlockEnd,
+      FlowGramNode.Break,
+      FlowGramNode.Continue
+    ];
+    if (terminatingNodeTypes.includes(node.type)) {
       return;
     }
     if (nextNodes.length === 0) {