@ai-setting/roy-agent-core 1.4.10 → 1.4.12

package/dist/env/workflow/decorators/index.js

@@ -0,0 +1,449 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/workflow/decorators/decorator-node.ts
+class DecoratorNode {
+  type = "decorator";
+  id;
+  methodName;
+  instance;
+  dependsOn;
+  timeout;
+  retryConfig;
+  constructor(definition) {
+    const config = definition.config;
+    this.id = definition.id;
+    this.methodName = config._methodName;
+    this.instance = config._instance;
+    this.dependsOn = definition.depends_on || [];
+    this.timeout = definition.timeout;
+    this.retryConfig = definition.retry;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    const method = this.instance[this.methodName];
+    if (typeof method !== "function") {
+      return {
+        success: false,
+        error: `Method '${this.methodName}' is not a function`,
+        duration: Date.now() - startTime
+      };
+    }
+    const input = this.prepareInput(context);
+    const result = await this.executeWithRetry(input, context.abort);
+    return {
+      success: !result.error,
+      output: result.output,
+      error: result.error,
+      duration: Date.now() - startTime,
+      metadata: {
+        methodName: this.methodName
+      }
+    };
+  }
+  prepareInput(context) {
+    const nodeOutputs = context.nodeOutputs;
+    if (this.dependsOn.length === 0) {
+      return context.input || {};
+    }
+    const input = {};
+    for (const depId of this.dependsOn) {
+      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
+      if (depOutput && typeof depOutput === "object") {
+        if ("output" in depOutput) {
+          input[depId] = depOutput.output;
+        } else {
+          input[depId] = depOutput;
+        }
+      }
+    }
+    return input;
+  }
+  async executeWithRetry(input, abort) {
+    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
+    const backoff = this.retryConfig?.backoff ?? "exponential";
+    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      if (abort?.aborted) {
+        return { error: "Execution aborted" };
+      }
+      try {
+        const output = await this.executeWithTimeout(input, abort);
+        return { output };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
+          await this.sleep(delay, abort);
+        }
+      }
+    }
+    return { error: lastError?.message || "Unknown error" };
+  }
+  async executeWithTimeout(input, abort) {
+    if (!this.timeout) {
+      return this.instance[this.methodName](input);
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timeout after ${this.timeout}ms`));
+      }, this.timeout);
+    });
+    return Promise.race([
+      this.instance[this.methodName](input),
+      timeoutPromise
+    ]);
+  }
+  calculateBackoff(backoff, initialDelay, attempt) {
+    if (backoff === "exponential") {
+      return initialDelay * Math.pow(2, attempt);
+    }
+    return initialDelay;
+  }
+  sleep(ms, abort) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(resolve, ms);
+      abort?.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+}
+
+// packages/core/src/env/workflow/decorators/workflow.ts
+import"reflect-metadata";
+
+// packages/core/src/env/workflow/metadata/keys.ts
+var WORKFLOW_METADATA_KEY = Symbol("workflow:metadata");
+var NODE_METADATA_KEY = Symbol("workflow:node");
+var EDGE_METADATA_KEY = Symbol("workflow:edges");
+
+// packages/core/src/env/workflow/decorators/workflow.ts
+function Workflow(options) {
+  return function(target) {
+    const metadata = {
+      name: options.name,
+      version: options.version || "1.0",
+      description: options.description,
+      entry: options.entry,
+      config: options.config,
+      tags: options.tags || [],
+      author: options.author
+    };
+    Reflect.defineMetadata(WORKFLOW_METADATA_KEY, metadata, target);
+    return target;
+  };
+}
+function getWorkflowMetadata(target) {
+  return Reflect.getMetadata(WORKFLOW_METADATA_KEY, target);
+}
+// packages/core/src/env/workflow/decorators/node-as.ts
+import"reflect-metadata";
+function NodeAs(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    const nodeMetadata = {
+      nodeId: options.nodeId || methodName,
+      nodeType: options.nodeType || "tool",
+      name: options.name,
+      dependsOn: normalizeDependsOn(options.dependsOn),
+      condition: options.condition,
+      retry: options.retry,
+      timeout: options.timeout,
+      config: options.config || {},
+      methodName,
+      method: descriptor.value
+    };
+    const existingNodes = Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+    const existingIndex = existingNodes.findIndex((n) => n.methodName === methodName);
+    if (existingIndex >= 0) {
+      existingNodes[existingIndex] = nodeMetadata;
+    } else {
+      existingNodes.push(nodeMetadata);
+    }
+    Reflect.defineMetadata(NODE_METADATA_KEY, existingNodes, target);
+    return descriptor;
+  };
+}
+function normalizeDependsOn(dependsOn) {
+  if (!dependsOn) {
+    return [];
+  }
+  return Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+}
+function getNodeMetadatas(target) {
+  return Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+}
+// packages/core/src/env/workflow/decorators/edge.ts
+import"reflect-metadata";
+function Edge(from, to) {
+  return function(target, propertyKey, descriptor) {
+    const edge = { from, to };
+    const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+    existingEdges.push(edge);
+    Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
+    return descriptor;
+  };
+}
+function WorkflowEdges(edges) {
+  return function(target) {
+    const edgeMetadatas = edges.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      condition: edge.condition
+    }));
+    Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
+    return target;
+  };
+}
+function getEdgeMetadatas(target) {
+  return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
+}
+// packages/core/src/env/workflow/extractor/workflow-converter.ts
+import"reflect-metadata";
+class WorkflowConverter {
+  static extractWorkflowMetadata(targetClass) {
+    return getWorkflowMetadata(targetClass);
+  }
+  static extractNodeMetadatas(targetClass) {
+    return getNodeMetadatas(targetClass.prototype);
+  }
+  static extractEdgeMetadatas(targetClass) {
+    return getEdgeMetadatas(targetClass);
+  }
+  static fromClass(targetClass, instance) {
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      throw new Error("Class must be decorated with @Workflow");
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      throw new Error("At least one method must be decorated with @NodeAs");
+    }
+    const edgeMetadatas = this.extractEdgeMetadatas(targetClass);
+    const nodeMap = this.buildNodeMap(nodeMetadatas, edgeMetadatas);
+    const nodes = Array.from(nodeMap.values()).map((meta) => ({
+      id: meta.nodeId,
+      type: meta.nodeType,
+      name: meta.name,
+      config: {
+        ...meta.config,
+        _methodName: meta.methodName,
+        _instance: instance
+      },
+      depends_on: meta.dependsOn,
+      condition: meta.condition,
+      retry: meta.retry,
+      timeout: meta.timeout
+    }));
+    const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
+    return {
+      name: workflowMeta.name,
+      version: workflowMeta.version || "1.0",
+      description: workflowMeta.description,
+      config: workflowMeta.config || {},
+      nodes,
+      entry,
+      outputs: [],
+      metadata: {
+        tags: workflowMeta.tags || [],
+        author: workflowMeta.author
+      }
+    };
+  }
+  static buildNodeMap(nodeMetadatas, edgeMetadatas) {
+    const nodeMap = new Map;
+    for (const nodeMeta of nodeMetadatas) {
+      nodeMap.set(nodeMeta.nodeId, { ...nodeMeta });
+    }
+    for (const edge of edgeMetadatas) {
+      const targetNode = nodeMap.get(edge.to);
+      if (targetNode) {
+        if (!targetNode.dependsOn.includes(edge.from)) {
+          targetNode.dependsOn = [...targetNode.dependsOn, edge.from];
+        }
+        if (edge.condition) {
+          if (targetNode.condition) {
+            targetNode.condition = `(${targetNode.condition}) AND (${edge.condition})`;
+          } else {
+            targetNode.condition = edge.condition;
+          }
+        }
+      }
+    }
+    return nodeMap;
+  }
+  static validateWorkflowClass(targetClass) {
+    const errors = [];
+    const warnings = [];
+    const workflowMeta = this.extractWorkflowMetadata(targetClass);
+    if (!workflowMeta) {
+      errors.push("Class must be decorated with @Workflow");
+      return { valid: false, errors, warnings };
+    }
+    const nodeMetadatas = this.extractNodeMetadatas(targetClass);
+    if (nodeMetadatas.length === 0) {
+      errors.push("At least one method must be decorated with @NodeAs");
+      return { valid: false, errors, warnings };
+    }
+    const entry = workflowMeta.entry;
+    if (entry) {
+      const entries = Array.isArray(entry) ? entry : [entry];
+      for (const e of entries) {
+        if (!nodeMetadatas.find((n) => n.nodeId === e)) {
+          errors.push(`Entry node '${e}' not found`);
+        }
+      }
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        if (!nodeMetadatas.find((n) => n.nodeId === dep)) {
+          errors.push(`Node '${node.nodeId}' depends on non-existent node '${dep}'`);
+        }
+      }
+    }
+    if (this.hasCycle(nodeMetadatas)) {
+      errors.push("Workflow contains a cycle");
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  static hasCycle(nodeMetadatas) {
+    const visited = new Set;
+    const recStack = new Set;
+    const adjList = new Map;
+    for (const node of nodeMetadatas) {
+      adjList.set(node.nodeId, []);
+    }
+    for (const node of nodeMetadatas) {
+      for (const dep of node.dependsOn) {
+        const deps = adjList.get(dep);
+        if (deps) {
+          deps.push(node.nodeId);
+        }
+      }
+    }
+    const dfs = (nodeId) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const neighbors = adjList.get(nodeId) || [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor)) {
+            return true;
+          }
+        } else if (recStack.has(neighbor)) {
+          return true;
+        }
+      }
+      recStack.delete(nodeId);
+      return false;
+    };
+    for (const node of nodeMetadatas) {
+      if (!visited.has(node.nodeId)) {
+        if (dfs(node.nodeId)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  static async executeNode(nodeDef, context) {
+    const instance = nodeDef.config._instance;
+    const methodName = nodeDef.config._methodName;
+    if (!instance || !methodName) {
+      return { output: undefined, error: new Error("Missing method information") };
+    }
+    const method = instance[methodName];
+    if (typeof method !== "function") {
+      return { output: undefined, error: new Error(`Method ${methodName} is not a function`) };
+    }
+    const deps = nodeDef.depends_on || [];
+    let input = context.input;
+    if (deps.length > 0) {
+      input = {};
+      for (const depId of deps) {
+        input[depId] = context.previousOutputs.get(depId);
+      }
+    }
+    try {
+      const result = await method.call(instance, input);
+      return { output: result };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+}
+// packages/core/src/env/workflow/utils/create-workflow.ts
+function createWorkflowFromClass(targetClass, options) {
+  const instance = options?.instance ?? new targetClass(...options?.constructorArgs ?? []);
+  return WorkflowConverter.fromClass(targetClass, instance);
+}
+export {
+  getWorkflowMetadata,
+  getNodeMetadatas,
+  getEdgeMetadatas,
+  createWorkflowFromClass,
+  WorkflowEdges,
+  WorkflowConverter,
+  Workflow,
+  NodeAs,
+  Edge,
+  DecoratorNode
+};