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

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

@@ -1,449 +0,0 @@
-// @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
-};