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

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

@@ -0,0 +1,603 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/nodes/tool-node.ts
+class ToolNode {
+  definition;
+  toolRegistry;
+  type = "tool";
+  id;
+  constructor(definition, toolRegistry) {
+    this.definition = definition;
+    this.toolRegistry = toolRegistry;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const toolName = this.definition.config?.tool ?? this.definition.config?.toolName;
+      if (!toolName) {
+        throw new Error("Tool name is required. Please specify config.tool or config.toolName in the node definition.");
+      }
+      let tool;
+      if (this.toolRegistry.getTool) {
+        const result = this.toolRegistry.getTool(toolName);
+        if (!result) {
+          throw new Error(`Tool not found: ${toolName}`);
+        }
+        if ("tool" in result) {
+          tool = result.tool;
+        } else {
+          tool = result;
+        }
+      } else if (this.toolRegistry.getToolByName) {
+        tool = this.toolRegistry.getToolByName(toolName);
+      }
+      if (!tool) {
+        throw new Error(`Tool not found: ${toolName}`);
+      }
+      let input;
+      if (this.definition.config?.command !== undefined) {
+        const commandTemplate = this.definition.config.command;
+        const resolvedCommand = this.resolveTemplateReferences(commandTemplate, context.previousOutputs, context.input);
+        input = { command: resolvedCommand };
+        console.log(`[ToolNode] command input: ${resolvedCommand}`);
+      } else if (this.definition.config?.message !== undefined && Object.keys(this.definition.config).length === 1) {
+        const messageTemplate = this.definition.config.message;
+        const resolvedMessage = this.resolveTemplateReferences(messageTemplate, context.previousOutputs, context.input);
+        input = { message: resolvedMessage };
+        console.log(`[ToolNode] message input: ${resolvedMessage}`);
+      } else {
+        input = this.definition.config?.input ?? this.definition.config?.args ?? {};
+        input = this.resolveTemplateReferences(input, context.previousOutputs, context.input);
+      }
+      let output;
+      try {
+        const toolContext = {
+          session_id: context.sessionId || `workflow_${context.runId}`,
+          message_id: context.nodeId,
+          metadata: {
+            workflowRunId: context.runId,
+            workflowName: context.workflowName,
+            nodeId: context.nodeId
+          }
+        };
+        const executePromise = tool.execute(input, toolContext);
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error(`Tool ${toolName} execution timeout after 30s`)), 30000);
+        });
+        output = await Promise.race([executePromise, timeoutPromise]);
+      } catch (err) {
+        console.log(`[ToolNode] Tool ${toolName} doesn't support context, retrying without context...`);
+        output = await tool.execute(input);
+      }
+      return {
+        output,
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveTemplateReferences(input, previousOutputs, workflowInput) {
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input) || this.extractDollarTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
+      }
+      return this.resolveStringTemplate(input, previousOutputs, workflowInput);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
+    }
+    if (input !== null && typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  extractDollarTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("${") && trimmed.endsWith("}") && trimmed.length > 3) {
+      const content = trimmed.slice(2, -1).trim();
+      if (!content.includes("${") && !content.includes("}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
+    const trimmed = templateContent.trim();
+    const originalTemplate = `{{${templateContent}}}`;
+    if (trimmed.startsWith("input.")) {
+      const value = this.getNestedValue(workflowInput, trimmed.slice(6));
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const path = trimmed.slice(6);
+      const segments = path.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    return originalTemplate;
+  }
+  resolveStringTemplate(template, previousOutputs, workflowInput) {
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\$\{input\.([^}]+)\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\$\{([^}]+)\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const nodeOutput = this.resolvePath(nodeId, undefined, previousOutputs);
+      let extractedValue = this.extractFromWrapper(nodeOutput);
+      if (typeof extractedValue === "string" && restPath === "output") {
+        return this.stringifyValue(extractedValue, match);
+      }
+      if (restPath) {
+        const value = this.getNestedValue(extractedValue, restPath);
+        return this.stringifyValue(value, match);
+      } else {
+        return this.stringifyValue(extractedValue, match);
+      }
+    });
+    return resolved;
+  }
+  resolvePath(nodeId, path, previousOutputs) {
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined) {
+      return;
+    }
+    if (path === undefined || path === "") {
+      return nodeOutput;
+    }
+    return this.getNestedValue(nodeOutput, path);
+  }
+  getNestedValue(obj, path) {
+    if (obj === null || obj === undefined) {
+      return;
+    }
+    const segments = path.split(".");
+    let current = obj;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  extractFromWrapper(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    let result;
+    if ("output" in value) {
+      result = value.output;
+    } else if ("result" in value && !("output" in value)) {
+      result = value.result;
+    } else {
+      return value;
+    }
+    if (typeof result === "string") {
+      return result.trimEnd();
+    }
+    return result;
+  }
+  stringifyValue(value, fallback) {
+    if (value === undefined || value === null) {
+      return fallback;
+    }
+    let str;
+    if (typeof value === "object") {
+      str = JSON.stringify(value);
+    } else {
+      str = String(value);
+    }
+    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 {
+  definition;
+  skillRegistry;
+  type = "skill";
+  id;
+  constructor(definition, skillRegistry) {
+    this.definition = definition;
+    this.skillRegistry = skillRegistry;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const skillName = this.definition.config?.skill;
+      if (!skillName) {
+        throw new Error("Skill name is required. Please specify config.skill in the node definition.");
+      }
+      const skill = this.skillRegistry.getSkill(skillName);
+      if (!skill) {
+        throw new Error(`Skill not found: ${skillName}`);
+      }
+      const input = this.definition.config?.input ?? {};
+      const resolvedInput = this.resolveTemplateReferences(input, context.previousOutputs, context.input);
+      const skillContext = {
+        runId: context.runId,
+        workflowName: context.workflowName,
+        nodeId: context.nodeId,
+        debug: context.debug
+      };
+      const output = await skill.invoke(resolvedInput, skillContext);
+      return {
+        output,
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveTemplateReferences(input, previousOutputs, workflowInput) {
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
+      }
+      return this.resolveStringTemplate(input, previousOutputs, workflowInput);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
+    }
+    if (input !== null && typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
+    const trimmed = templateContent.trim();
+    const originalTemplate = `{{${templateContent}}}`;
+    if (trimmed.startsWith("input.")) {
+      const value = this.getNestedValue(workflowInput, trimmed.slice(6));
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const path = trimmed.slice(6);
+      const segments = path.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    return originalTemplate;
+  }
+  resolveStringTemplate(template, previousOutputs, workflowInput) {
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    return resolved;
+  }
+  resolvePath(nodeId, path, previousOutputs) {
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined) {
+      return;
+    }
+    let value = this.extractFromWrapper(nodeOutput);
+    if (!path) {
+      return value;
+    }
+    let segments = path.split(".");
+    if (segments.length > 1 && (segments[0] === "output" || segments[0] === "result" || segments[0] === "metadata")) {
+      segments = segments.slice(1);
+    }
+    let current = value;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  extractFromWrapper(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    if ("result" in value && "metadata" in value) {
+      return value.result;
+    }
+    if ("output" in value) {
+      return value.output;
+    }
+    return value;
+  }
+  getNestedValue(obj, path) {
+    if (!obj) {
+      return;
+    }
+    if ("input" in obj && path in obj["input"]) {
+      return obj["input"][path];
+    }
+    return path.split(".").reduce((current, key) => {
+      if (current && typeof current === "object") {
+        return current[key];
+      }
+      return;
+    }, obj);
+  }
+  stringifyValue(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+}
+var init_skill_node = () => {};
+
+// packages/core/src/env/workflow/nodes/workflow-node.ts
+class WorkflowNode {
+  workflowRunner;
+  type = "workflow";
+  id;
+  config;
+  constructor(definition, workflowRunner) {
+    this.workflowRunner = workflowRunner;
+    this.id = definition.id;
+    this.config = definition.config ?? {};
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const workflowName = this.config.workflow_name;
+      if (!workflowName) {
+        throw new Error("workflow_name is required in config. Please specify config.workflow_name in the node definition.");
+      }
+      const previousOutputs = context.previousOutputs ?? this.convertToMap(context.nodeOutputs ?? {});
+      const resolvedInput = this.resolveInput(this.config.input ?? {}, previousOutputs);
+      const result = await this.workflowRunner.run(workflowName, resolvedInput);
+      const success = result.status === "completed";
+      return {
+        success,
+        output: result.output,
+        error: success ? undefined : result.error,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  convertToMap(nodeOutputs) {
+    const map = new Map;
+    for (const [nodeId, result] of Object.entries(nodeOutputs)) {
+      map.set(nodeId, result.output);
+    }
+    return map;
+  }
+  resolveInput(input, previousOutputs) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(input)) {
+      resolved[key] = this.resolveValue(value, previousOutputs);
+    }
+    return resolved;
+  }
+  resolveValue(value, previousOutputs) {
+    if (typeof value === "string") {
+      return this.resolveStringTemplate(value, previousOutputs);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.resolveValue(item, previousOutputs));
+    }
+    if (value !== null && typeof value === "object") {
+      const resolved = {};
+      for (const [k, v] of Object.entries(value)) {
+        resolved[k] = this.resolveValue(v, previousOutputs);
+      }
+      return resolved;
+    }
+    return value;
+  }
+  resolveStringTemplate(template, previousOutputs) {
+    const templatePattern = /\{\{([^}]+)\}\}/g;
+    return template.replace(templatePattern, (match, path) => {
+      const trimmedPath = path.trim();
+      const value = this.resolvePath(trimmedPath, previousOutputs);
+      if (value !== undefined) {
+        return this.stringifyValue(value, match);
+      }
+      return match;
+    });
+  }
+  resolvePath(path, previousOutputs) {
+    const segments = path.split(".");
+    if (segments.length === 0) {
+      return;
+    }
+    const nodeId = segments[0];
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      return;
+    }
+    nodeOutput = this.extractFromWrapper(nodeOutput);
+    if (segments.length === 1) {
+      return nodeOutput;
+    }
+    let current = nodeOutput;
+    let startIndex = 1;
+    if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
+      startIndex = 2;
+    }
+    for (let i = startIndex;i < segments.length; i++) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      current = current[segments[i]];
+    }
+    return current;
+  }
+  extractFromWrapper(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    if ("result" in value && "metadata" in value) {
+      return value.result;
+    }
+    if ("output" in value) {
+      return value.output;
+    }
+    return value;
+  }
+  stringifyValue(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+}
+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 };