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

package/dist/shared/@ai-setting/roy-agent-core-3tnb2005.js

@@ -0,0 +1,117 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// 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();
+      });
+    });
+  }
+}
+var init_decorator_node = () => {};
+
+export { DecoratorNode, init_decorator_node };

package/dist/shared/@ai-setting/roy-agent-core-4vmcvkav.js

@@ -0,0 +1,14 @@
+import {
+  WorkflowRepository,
+  rowToWorkflow
+} from "./roy-agent-core-tkr5ynkh.js";
+import"./roy-agent-core-qxybm159.js";
+import"./roy-agent-core-0sgn3de4.js";
+import"./roy-agent-core-yn761yve.js";
+import"./roy-agent-core-1k28kg7h.js";
+import"./roy-agent-core-j8zx62zr.js";
+import"./roy-agent-core-fs0mn2jk.js";
+export {
+  rowToWorkflow,
+  WorkflowRepository
+};

package/dist/shared/{chunk-25x2pdtp.js → @ai-setting/roy-agent-core-4ws8atva.js}

@@ -1,8 +1,8 @@
 import {
   __esm
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/workflow/utils/session-recovery.ts
+// packages/core/src/env/workflow/utils/session-recovery.ts
 function inferNextNode(messages, definition) {
   if (messages.length === 0) {
     return { type: "entry_node", nodeId: definition.entryNode };