@ai-setting/roy-agent-core 1.4.12 → 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/@ai-setting/roy-agent-core-4ws8atva.js

@@ -0,0 +1,107 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/utils/session-recovery.ts
+function inferNextNode(messages, definition) {
+  if (messages.length === 0) {
+    return { type: "entry_node", nodeId: definition.entryNode };
+  }
+  const lastMessage = messages[messages.length - 1];
+  const metadata = lastMessage.metadata;
+  switch (metadata?.type) {
+    case "workflow.node.call":
+      return {
+        type: "resume_node",
+        nodeId: metadata.workflowNodeId,
+        agentSessionId: metadata.agentSessionId
+      };
+    case "workflow.node.interrupt":
+      return {
+        type: "ask_user",
+        nodeId: metadata.workflowNodeId,
+        agentSessionId: metadata.agentSessionId
+      };
+    case "workflow.node.result":
+      return getNextNodes(metadata.workflowNodeId, definition);
+    default:
+      const lastCall = findLastCallMessage(messages);
+      if (lastCall) {
+        const callMetadata = lastCall.metadata;
+        return {
+          type: "resume_node",
+          nodeId: callMetadata.workflowNodeId,
+          agentSessionId: callMetadata.agentSessionId
+        };
+      }
+      return { type: "entry_node", nodeId: definition.entryNode };
+  }
+}
+function getNextNodes(completedNodeId, definition) {
+  if (!definition.edges) {
+    return { type: "next_nodes", nodeIds: [] };
+  }
+  const nextNodeIds = definition.edges.filter((edge) => edge.from === completedNodeId).map((edge) => edge.to);
+  return { type: "next_nodes", nodeIds: nextNodeIds };
+}
+function findLastInterruptMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.metadata?.type === "workflow.node.interrupt") {
+      return msg;
+    }
+  }
+  return null;
+}
+function findLastCallMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.metadata?.type === "workflow.node.call") {
+      return msg;
+    }
+  }
+  return null;
+}
+function parseNodeOutputs(messages) {
+  const outputs = new Map;
+  let lastCallNodeId = null;
+  for (const msg of messages) {
+    const metadata = msg.metadata;
+    if (metadata?.type === "workflow.node.call") {
+      lastCallNodeId = metadata.workflowNodeId;
+    } else if (metadata?.type === "workflow.node.result" && lastCallNodeId) {
+      try {
+        outputs.set(lastCallNodeId, JSON.parse(msg.content));
+      } catch {
+        outputs.set(lastCallNodeId, msg.content);
+      }
+      lastCallNodeId = null;
+    }
+  }
+  return outputs;
+}
+function hasPendingAskUser(messages) {
+  if (messages.length === 0)
+    return false;
+  const lastMessage = messages[messages.length - 1];
+  const metadata = lastMessage.metadata;
+  return metadata?.type === "workflow.node.interrupt";
+}
+function getAgentSessionIdFromInterrupt(messages) {
+  const lastInterrupt = findLastInterruptMessage(messages);
+  if (!lastInterrupt)
+    return null;
+  const metadata = lastInterrupt.metadata;
+  return metadata?.agentSessionId || null;
+}
+var init_session_recovery = () => {};
+init_session_recovery();
+
+export {
+  parseNodeOutputs,
+  inferNextNode,
+  hasPendingAskUser,
+  getAgentSessionIdFromInterrupt,
+  findLastInterruptMessage,
+  findLastCallMessage
+};

package/dist/{env/workflow/nodes/index.js → shared/@ai-setting/roy-agent-core-5fbp24se.js}

@@ -1,53 +1,6 @@
-// @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;
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // packages/core/src/env/workflow/nodes/tool-node.ts
 class ToolNode {
@@ -311,6 +264,7 @@ class ToolNode {
     return str.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/"/g, "\\\"").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   }
 }
+var init_tool_node = () => {};
 
 // packages/core/src/env/workflow/nodes/skill-node.ts
 class SkillNode {
@@ -509,6 +463,7 @@ class SkillNode {
     return JSON.stringify(value);
   }
 }
+var init_skill_node = () => {};
 
 // packages/core/src/env/workflow/nodes/workflow-node.ts
 class WorkflowNode {
@@ -643,8 +598,6 @@ class WorkflowNode {
     return JSON.stringify(value);
   }
 }
-export {
-  WorkflowNode,
-  ToolNode,
-  SkillNode
-};
+var init_workflow_node = () => {};
+
+export { ToolNode, init_tool_node, SkillNode, init_skill_node, WorkflowNode, init_workflow_node };

package/dist/shared/@ai-setting/roy-agent-core-5my94ywp.js

@@ -0,0 +1,66 @@
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/paths.ts
+import os from "os";
+import path from "path";
+var APP_NAME = "roy-agent";
+function getXdgBase() {
+  const home = os.homedir();
+  try {
+    const xdg = __require("xdg-basedir");
+    return {
+      config: xdg.xdgConfig || path.join(home, ".config"),
+      state: xdg.xdgState || path.join(home, ".local", "state"),
+      data: xdg.xdgData || path.join(home, ".local", "share"),
+      cache: xdg.xdgCache || path.join(home, ".cache")
+    };
+  } catch {
+    return {
+      config: path.join(home, ".config"),
+      state: path.join(home, ".local", "state"),
+      data: path.join(home, ".local", "share"),
+      cache: path.join(home, ".cache")
+    };
+  }
+}
+function computeXDGPaths() {
+  const home = os.homedir();
+  const xdg = getXdgBase();
+  return {
+    home,
+    config: path.join(xdg.config, APP_NAME),
+    state: path.join(xdg.state, APP_NAME),
+    data: path.join(xdg.data, APP_NAME),
+    cache: path.join(xdg.cache, APP_NAME)
+  };
+}
+
+class XDGPathsCalculator {
+  _paths;
+  get paths() {
+    if (!this._paths) {
+      this._paths = computeXDGPaths();
+    }
+    return this._paths;
+  }
+  getPath(type) {
+    return this.paths[type];
+  }
+  getComponentPath(base, subPath) {
+    return path.join(this.paths[base], subPath);
+  }
+  reset() {
+    this._paths = undefined;
+  }
+}
+var XDG_PATHS = new XDGPathsCalculator;
+function getXDGPaths() {
+  return XDG_PATHS.paths;
+}
+function getXDGPath(type) {
+  return XDG_PATHS.getPath(type);
+}
+
+export { XDG_PATHS, getXDGPaths, getXDGPath };