@flowgram.ai/runtime-js 0.2.23 → 0.2.25

package/dist/{index.d.mts → index.d.cts}

@@ -4,7 +4,7 @@ declare enum FlowGramAPIName {
     TaskReport = "TaskReport",
     TaskResult = "TaskResult",
     TaskCancel = "TaskCancel",
-    Validation = "Validation"
+    TaskValidate = "TaskValidate"
 }
 
 /**
@@ -14,6 +14,16 @@ declare enum FlowGramAPIName {
 type WorkflowInputs = Record<string, any>;
 type WorkflowOutputs = Record<string, any>;
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -115,6 +125,18 @@ interface TaskReportInput {
 }
 type TaskReportOutput = IReport | undefined;
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface TaskValidateInput {
+    inputs: WorkflowInputs;
+    schema: string;
+}
+interface TaskValidateOutput extends ValidationResult {
+}
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -137,6 +159,13 @@ type TaskCancelOutput = {
     success: boolean;
 };
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const TaskValidateAPI: (input: TaskValidateInput) => Promise<TaskValidateOutput>;
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -172,4 +201,4 @@ declare const TaskCancelAPI: (input: TaskCancelInput) => Promise<TaskCancelOutpu
 
 declare const WorkflowRuntimeAPIs: Record<FlowGramAPIName, (i: any) => any>;
 
-export { TaskCancelAPI, TaskReportAPI, TaskResultAPI, TaskRunAPI, WorkflowRuntimeAPIs };
+export { TaskCancelAPI, TaskReportAPI, TaskResultAPI, TaskRunAPI, TaskValidateAPI, WorkflowRuntimeAPIs };

package/dist/index.d.ts

@@ -4,7 +4,7 @@ declare enum FlowGramAPIName {
     TaskReport = "TaskReport",
     TaskResult = "TaskResult",
     TaskCancel = "TaskCancel",
-    Validation = "Validation"
+    TaskValidate = "TaskValidate"
 }
 
 /**
@@ -14,6 +14,16 @@ declare enum FlowGramAPIName {
 type WorkflowInputs = Record<string, any>;
 type WorkflowOutputs = Record<string, any>;
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -115,6 +125,18 @@ interface TaskReportInput {
 }
 type TaskReportOutput = IReport | undefined;
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface TaskValidateInput {
+    inputs: WorkflowInputs;
+    schema: string;
+}
+interface TaskValidateOutput extends ValidationResult {
+}
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -137,6 +159,13 @@ type TaskCancelOutput = {
     success: boolean;
 };
 
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const TaskValidateAPI: (input: TaskValidateInput) => Promise<TaskValidateOutput>;
+
 /**
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
@@ -172,4 +201,4 @@ declare const TaskCancelAPI: (input: TaskCancelInput) => Promise<TaskCancelOutpu
 
 declare const WorkflowRuntimeAPIs: Record<FlowGramAPIName, (i: any) => any>;
 
-export { TaskCancelAPI, TaskReportAPI, TaskResultAPI, TaskRunAPI, WorkflowRuntimeAPIs };
+export { TaskCancelAPI, TaskReportAPI, TaskResultAPI, TaskRunAPI, TaskValidateAPI, WorkflowRuntimeAPIs };

package/dist/index.js

@@ -34,98 +34,98 @@ __export(src_exports, {
   TaskReportAPI: () => TaskReportAPI,
   TaskResultAPI: () => TaskResultAPI,
   TaskRunAPI: () => TaskRunAPI,
+  TaskValidateAPI: () => TaskValidateAPI,
   WorkflowRuntimeAPIs: () => WorkflowRuntimeAPIs
 });
 module.exports = __toCommonJS(src_exports);
 
 // ../interface/dist/esm/index.js
-var import_zod = __toESM(require("zod"));
-var import_zod2 = __toESM(require("zod"));
-var import_zod3 = __toESM(require("zod"));
-var import_zod4 = __toESM(require("zod"));
-var import_zod5 = __toESM(require("zod"));
-var import_zod6 = __toESM(require("zod"));
-var import_zod7 = __toESM(require("zod"));
+var import_zod = __toESM(require("zod"), 1);
+var import_zod2 = __toESM(require("zod"), 1);
+var import_zod3 = __toESM(require("zod"), 1);
+var import_zod4 = __toESM(require("zod"), 1);
+var import_zod5 = __toESM(require("zod"), 1);
+var import_zod6 = __toESM(require("zod"), 1);
+var import_zod7 = __toESM(require("zod"), 1);
+var WorkflowIOZodSchema = import_zod2.default.record(import_zod2.default.string(), import_zod2.default.any());
+var WorkflowSnapshotZodSchema = import_zod2.default.object({
+  id: import_zod2.default.string(),
+  nodeID: import_zod2.default.string(),
+  inputs: WorkflowIOZodSchema,
+  outputs: WorkflowIOZodSchema.optional(),
+  data: WorkflowIOZodSchema,
+  branch: import_zod2.default.string().optional()
+});
+var WorkflowStatusZodShape = {
+  status: import_zod2.default.string(),
+  terminated: import_zod2.default.boolean(),
+  startTime: import_zod2.default.number(),
+  endTime: import_zod2.default.number().optional(),
+  timeCost: import_zod2.default.number()
+};
+var WorkflowStatusZodSchema = import_zod2.default.object(WorkflowStatusZodShape);
+var WorkflowNodeReportZodSchema = import_zod2.default.object({
+  id: import_zod2.default.string(),
+  ...WorkflowStatusZodShape,
+  snapshots: import_zod2.default.array(WorkflowSnapshotZodSchema)
+});
+var WorkflowReportsZodSchema = import_zod2.default.record(import_zod2.default.string(), WorkflowNodeReportZodSchema);
+var WorkflowMessageZodSchema = import_zod2.default.object({
+  id: import_zod2.default.string(),
+  type: import_zod2.default.enum(["log", "info", "debug", "error", "warning"]),
+  message: import_zod2.default.string(),
+  nodeID: import_zod2.default.string().optional(),
+  timestamp: import_zod2.default.number()
+});
+var WorkflowMessagesZodSchema = import_zod2.default.record(
+  import_zod2.default.enum(["log", "info", "debug", "error", "warning"]),
+  import_zod2.default.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: import_zod.default.object({
-      schema: import_zod.default.string()
+      schema: import_zod.default.string(),
+      inputs: WorkflowZodSchema.Inputs
     }),
     output: import_zod.default.object({
       valid: import_zod.default.boolean(),
-      nodeErrors: import_zod.default.array(
-        import_zod.default.object({
-          message: import_zod.default.string(),
-          nodeID: import_zod.default.string()
-        })
-      ),
-      edgeErrors: import_zod.default.array(
-        import_zod.default.object({
-          message: import_zod.default.string(),
-          edge: import_zod.default.object({
-            sourceNodeID: import_zod.default.string(),
-            targetNodeID: import_zod.default.string(),
-            sourcePortID: import_zod.default.string().optional(),
-            targetPortID: import_zod.default.string().optional()
-          })
-        })
-      )
+      errors: import_zod.default.array(import_zod.default.string()).optional()
     })
   }
 };
-var WorkflowIOZodSchema = import_zod3.default.record(import_zod3.default.string(), import_zod3.default.any());
-var WorkflowSnapshotZodSchema = import_zod3.default.object({
-  id: import_zod3.default.string(),
-  nodeID: import_zod3.default.string(),
-  inputs: WorkflowIOZodSchema,
-  outputs: WorkflowIOZodSchema.optional(),
-  data: WorkflowIOZodSchema,
-  branch: import_zod3.default.string().optional()
-});
-var WorkflowStatusZodShape = {
-  status: import_zod3.default.string(),
-  terminated: import_zod3.default.boolean(),
-  startTime: import_zod3.default.number(),
-  endTime: import_zod3.default.number().optional(),
-  timeCost: import_zod3.default.number()
-};
-var WorkflowStatusZodSchema = import_zod3.default.object(WorkflowStatusZodShape);
-var WorkflowZodSchema = {
-  Inputs: WorkflowIOZodSchema,
-  Outputs: WorkflowIOZodSchema,
-  Status: WorkflowStatusZodSchema,
-  Snapshot: WorkflowSnapshotZodSchema,
-  NodeReport: import_zod3.default.object({
-    id: import_zod3.default.string(),
-    ...WorkflowStatusZodShape,
-    snapshots: import_zod3.default.array(WorkflowSnapshotZodSchema)
-  })
-};
 var TaskRunDefine = {
   name: "TaskRun",
   method: "POST",
   path: "/task/run",
   module: "Task",
   schema: {
-    input: import_zod2.default.object({
-      schema: import_zod2.default.string(),
+    input: import_zod3.default.object({
+      schema: import_zod3.default.string(),
       inputs: WorkflowZodSchema.Inputs
     }),
-    output: import_zod2.default.object({
-      taskID: import_zod2.default.string()
+    output: import_zod3.default.object({
+      taskID: import_zod3.default.string()
     })
   }
 };
@@ -155,7 +155,8 @@ var TaskReportDefine = {
       inputs: WorkflowZodSchema.Inputs,
       outputs: WorkflowZodSchema.Outputs,
       workflowStatus: WorkflowZodSchema.Status,
-      reports: import_zod5.default.record(import_zod5.default.string(), WorkflowZodSchema.NodeReport)
+      reports: WorkflowZodSchema.Reports,
+      messages: WorkflowZodSchema.Messages
     })
   }
 };
@@ -210,9 +211,9 @@ var FlowGramAPIs = {
     /* TaskCancel */
   ]: TaskCancelDefine,
   [
-    "Validation"
-    /* Validation */
-  ]: ValidationDefine
+    "TaskValidate"
+    /* TaskValidate */
+  ]: TaskValidateDefine
 };
 var FlowGramAPINames = Object.keys(FlowGramAPIs);
 var WorkflowPortType = /* @__PURE__ */ ((WorkflowPortType2) => {
@@ -402,6 +403,205 @@ function compareNodeGroups(groupA, groupB) {
   };
 }
 
+// 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() {
@@ -920,11 +1120,48 @@ var WorkflowRuntimeNodeExecutors = [
 
 // 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
@@ -1932,11 +2169,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();
@@ -2003,6 +2248,19 @@ var WorkflowRuntimeEngine = class {
       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;
     const prevNodes = node.prev;
@@ -2071,6 +2329,7 @@ var WorkflowRuntimeContainer = class _WorkflowRuntimeContainer {
     const Validation = new WorkflowRuntimeValidation();
     const Executor = new WorkflowRuntimeExecutor(WorkflowRuntimeNodeExecutors);
     const Engine = new WorkflowRuntimeEngine({
+      Validation,
       Executor
     });
     return {
@@ -2127,6 +2386,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;
@@ -2136,6 +2401,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;
@@ -2186,16 +2464,14 @@ 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
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2203,6 +2479,7 @@ var WorkflowRuntimeAPIs = {
   TaskReportAPI,
   TaskResultAPI,
   TaskRunAPI,
+  TaskValidateAPI,
   WorkflowRuntimeAPIs
 });
 //# sourceMappingURL=index.js.map