@ai-setting/roy-agent-core 1.5.42 → 1.5.44

package/dist/shared/@ai-setting/roy-agent-core-6vxg2gmr.js

@@ -0,0 +1,321 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  __esm,
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/nodes/tool-node.ts
+var ToolNode;
+var init_tool_node = __esm(() => {
+  init_decorator();
+  ToolNode = 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}`);
+        }
+        const config = context.resolvedConfig ?? (this.definition.config || {});
+        const rawInput = config.input ?? config.inputs ?? config.args;
+        const rawCommand = config.command;
+        const rawMessage = config.message;
+        const hasResolvedConfig = context.resolvedConfig !== undefined;
+        let input;
+        if (rawCommand !== undefined) {
+          input = {
+            command: hasResolvedConfig ? rawCommand : context.templateResolver ? context.templateResolver.resolveValue(rawCommand) : rawCommand
+          };
+        } else if (rawMessage !== undefined) {
+          input = {
+            message: hasResolvedConfig ? rawMessage : context.templateResolver ? context.templateResolver.resolveValue(rawMessage) : rawMessage
+          };
+        } else if (rawInput !== undefined) {
+          input = hasResolvedConfig ? rawInput : context.templateResolver ? context.templateResolver.resolveValue(rawInput) : rawInput;
+        } else {
+          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 60 seconds`)), 60000);
+          });
+          output = await Promise.race([executePromise, timeoutPromise]);
+        } catch (toolError) {
+          if (toolError instanceof TypeError && toolError.message.includes("context") && toolError.message.includes("not a function")) {
+            output = await tool.execute(input);
+          } else {
+            throw toolError;
+          }
+        }
+        const extractedOutput = this.extractFromWrapper(output);
+        return {
+          output: extractedOutput,
+          error: undefined,
+          durationMs: Date.now() - startTime
+        };
+      } catch (error) {
+        return {
+          output: undefined,
+          error: error instanceof Error ? error : new Error(String(error)),
+          durationMs: Date.now() - startTime
+        };
+      }
+    }
+    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;
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.tool.execute", { log: true })
+  ], ToolNode.prototype, "execute", null);
+});
+
+// src/env/workflow/nodes/skill-node.ts
+var SkillNode;
+var init_skill_node = __esm(() => {
+  init_decorator();
+  SkillNode = 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 config = context.resolvedConfig ?? this.definition.config ?? {};
+        const input = config.input ?? {};
+        const resolvedInput = context.templateResolver ? context.templateResolver.resolveValue(input) : input;
+        const skillContext = {
+          runId: context.runId,
+          workflowName: context.workflowName,
+          nodeId: context.nodeId,
+          debug: context.debug,
+          sessionId: context.sessionId
+        };
+        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
+        };
+      }
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.skill.execute", { log: true })
+  ], SkillNode.prototype, "execute", null);
+});
+
+// src/env/workflow/nodes/workflow-node.ts
+class WorkflowNode {
+  definition;
+  workflowRunner;
+  type = "workflow";
+  id;
+  constructor(definition, workflowRunner) {
+    this.definition = definition;
+    this.workflowRunner = workflowRunner;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const config = context.resolvedConfig ?? this.definition.config ?? {};
+      const workflowName = 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(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-0rtxwr28.js → roy-agent-core-9bmtxmp6.js}

@@ -2,143 +2,100 @@ import {
   DecoratorNode,
   init_decorator_node
 } from "./roy-agent-core-1ce3fqrk.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   __esm,
-  __export
+  __export,
+  __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/nodes/condition-node.ts
-class ConditionNode {
-  definition;
-  type = "condition";
-  id;
-  constructor(definition) {
-    this.definition = definition;
-    this.id = definition.id;
-  }
-  async execute(context) {
-    const startTime = Date.now();
-    try {
-      const conditionConfig = this.definition.config?.condition;
-      if (conditionConfig === undefined) {
+var logger, ConditionNode;
+var init_condition_node = __esm(() => {
+  init_decorator();
+  init_logger();
+  logger = createLogger("workflow.condition");
+  ConditionNode = class ConditionNode {
+    definition;
+    type = "condition";
+    id;
+    constructor(definition) {
+      this.definition = definition;
+      this.id = definition.id;
+    }
+    async execute(context) {
+      const startTime = Date.now();
+      try {
+        const rawCondition = this.definition.config?.condition;
+        if (rawCondition === undefined) {
+          return {
+            output: { success: true, condition: true },
+            error: undefined,
+            durationMs: Date.now() - startTime
+          };
+        }
+        let conditionConfig;
+        if (context.resolvedConfig !== undefined) {
+          conditionConfig = context.resolvedConfig.condition;
+        } else {
+          const containsTemplate = typeof rawCondition === "string" && /\{\{.*\}\}/.test(rawCondition);
+          if (containsTemplate && !context.templateResolver) {
+            logger.warn(`[ConditionNode:${this.id}] Condition contains template references "{{...}}" but ` + `templateResolver is not available. The condition will be evaluated as-is. ` + `To resolve templates, ensure the workflow engine provides a templateResolver.`);
+            conditionConfig = rawCondition;
+          } else if (context.templateResolver) {
+            conditionConfig = context.templateResolver.resolveValue(rawCondition);
+          } else {
+            conditionConfig = rawCondition;
+          }
+        }
+        const result = this.evaluateCondition(conditionConfig);
         return {
-          output: { success: true, condition: true },
+          output: { success: result, condition: conditionConfig },
           error: undefined,
           durationMs: Date.now() - startTime
         };
+      } catch (error) {
+        return {
+          output: undefined,
+          error: error instanceof Error ? error : new Error(String(error)),
+          durationMs: Date.now() - startTime
+        };
       }
-      const resolvedCondition = this.resolveCondition(conditionConfig, context);
-      const result = this.evaluateCondition(resolvedCondition);
-      return {
-        output: { success: result, condition: resolvedCondition },
-        error: undefined,
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        output: undefined,
-        error: error instanceof Error ? error : new Error(String(error)),
-        durationMs: Date.now() - startTime
-      };
-    }
-  }
-  resolveCondition(condition, context) {
-    if (typeof condition === "string") {
-      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
-      if (templateMatch) {
-        const path = templateMatch[1].trim();
-        return this.resolveTemplate(path, context);
-      }
-      if (condition === "true")
-        return true;
-      if (condition === "false")
-        return false;
-      return condition;
     }
-    return condition;
-  }
-  resolveTemplate(path, context) {
-    const trimmed = path.trim();
-    if (trimmed.startsWith("input.")) {
-      const key = trimmed.slice(6);
-      return context.input?.[key];
-    }
-    if (trimmed.startsWith("nodes.")) {
-      const rest = trimmed.slice(6);
-      const segments2 = rest.split(".");
-      const nodeId2 = segments2[0];
-      let nodeOutput2 = context.previousOutputs.get(nodeId2);
-      if (nodeOutput2 === undefined) {
-        const normalizedUnderscore = nodeId2.replace(/-/g, "_");
-        const normalizedHyphen = nodeId2.replace(/_/g, "-");
-        if (normalizedUnderscore !== nodeId2) {
-          nodeOutput2 = context.previousOutputs.get(normalizedUnderscore);
-        }
-        if (nodeOutput2 === undefined && normalizedHyphen !== nodeId2) {
-          nodeOutput2 = context.previousOutputs.get(normalizedHyphen);
-        }
+    evaluateCondition(value) {
+      if (typeof value === "boolean") {
+        return value;
       }
-      if (nodeOutput2 === undefined)
-        return;
-      let value2 = nodeOutput2;
-      for (const segment of segments2.slice(1)) {
-        if (value2 && typeof value2 === "object") {
-          value2 = value2[segment];
-        } else {
-          return;
-        }
+      if (typeof value === "string") {
+        return value.toLowerCase() === "true" || value === "1";
       }
-      return value2;
-    }
-    const segments = trimmed.split(".");
-    const nodeId = segments[0];
-    let nodeOutput = context.previousOutputs.get(nodeId);
-    if (nodeOutput === undefined) {
-      const normalizedUnderscore = nodeId.replace(/-/g, "_");
-      const normalizedHyphen = nodeId.replace(/_/g, "-");
-      if (normalizedUnderscore !== nodeId) {
-        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+      if (typeof value === "number") {
+        return value !== 0;
       }
-      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-        nodeOutput = context.previousOutputs.get(normalizedHyphen);
-      }
-    }
-    if (nodeOutput === undefined)
-      return;
-    let value = nodeOutput;
-    for (const segment of segments.slice(1)) {
-      if (value && typeof value === "object") {
-        value = value[segment];
-      } else {
-        return;
+      if (value === null || value === undefined) {
+        return false;
       }
-    }
-    return value;
-  }
-  evaluateCondition(value) {
-    if (typeof value === "boolean") {
-      return value;
-    }
-    if (typeof value === "string") {
-      return value.toLowerCase() === "true" || value === "1";
-    }
-    if (typeof value === "number") {
-      return value !== 0;
-    }
-    if (value === null || value === undefined) {
-      return false;
-    }
-    if (typeof value === "object") {
-      const obj = value;
-      if ("success" in obj) {
-        return Boolean(obj.success);
+      if (typeof value === "object") {
+        const obj = value;
+        if ("success" in obj) {
+          return Boolean(obj.success);
+        }
+        return Object.keys(obj).length > 0;
       }
-      return Object.keys(obj).length > 0;
+      return Boolean(value);
     }
-    return Boolean(value);
-  }
-}
-var init_condition_node = () => {};
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.condition.execute", { log: true })
+  ], ConditionNode.prototype, "execute", null);
+});
 
 // src/env/workflow/nodes/merge-node.ts
 class MergeNode {

package/dist/shared/@ai-setting/{roy-agent-core-xz22rmak.js → roy-agent-core-9p43ap7h.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_SUBAGENT_PROMPT
-} from "./roy-agent-core-7t05apnp.js";
+} from "./roy-agent-core-fg3j215p.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
@@ -53,13 +53,23 @@ async function resolveFromRegistry(subagentType, agentDef, builtIn, registry) {
     fromRegistry: true
   };
 }
+function buildAgentSelectionGuide(options) {
+  const customAgentNote = options.hasCustomAgents ? "- Custom agents from AgentRegistry are listed above." : "- Custom agents from AgentRegistry appear above when registered.";
+  return `
+## Agent Selection Guide
+
+- Choose \`subagent_type\` from the list above; use \`general\` when no specialized agent fits (default).
+${customAgentNote}
+- For full metadata: \`roy-agent agents list\`, \`roy-agent agents get <name>\`, \`roy-agent prompt list\`.`;
+}
 function listKnownSubagentDescriptions(registry) {
   const builtInLines = builtInSubAgents.map((agent) => `- ${agent.id}: ${agent.description}`);
   const registryAgents = registry?.listAgentsByType("sub") ?? [];
   const customLines = registryAgents.filter((agent) => !builtInSubAgents.some((builtIn) => builtIn.id === agent.name)).map((agent) => `- ${agent.name}: ${agent.description || "Custom agent"}`);
   const lines = [...builtInLines, ...customLines];
+  const guidance = buildAgentSelectionGuide({ hasCustomAgents: customLines.length > 0 });
   return lines.join(`
-`);
+`) + guidance;
 }
 
 // src/env/task/delegate/delegate-tool.ts
@@ -497,16 +507,21 @@ ${prompt}
     logger.info(`[BackgroundTaskManager] Disposed`);
   }
 }
+function getAgentRegistry(taskComponent) {
+  const agentComponent = taskComponent.env?.getComponent?.("agent");
+  return agentComponent?.getRegistry?.();
+}
 function createDelegateTool(taskComponent) {
   const env = taskComponent.env;
   const backgroundTaskManager = new BackgroundTaskManager(env);
+  const registry = getAgentRegistry(taskComponent);
   taskComponent._backgroundTaskManager = backgroundTaskManager;
   const tool = {
     name: "delegate_task",
     description: `Launch a new sub-agent to handle complex, multistep tasks autonomously.
 
 Available agent types:
-${listKnownSubagentDescriptions()}
+${listKnownSubagentDescriptions(registry)}
 
 When using the delegate_task tool, you must specify a subagent_type parameter to select which agent type to use.
 
@@ -533,9 +548,8 @@ When using the delegate_task tool, you must specify a subagent_type parameter to
       const { description, prompt, subagent_type = "general", background = false, timeout, cleanup, task_id, reason } = params;
       const parentSessionId = ctx.session_id || "default";
       logger.info(`[delegate_task] Called: description=${description}, subagent_type=${subagent_type}, background=${background}, task_id=${task_id}`);
-      const agentComponent = taskComponent.env?.getComponent?.("agent");
-      const registry = agentComponent?.getRegistry?.();
-      if (!isKnownSubagentType(subagent_type, registry)) {
+      const registry2 = getAgentRegistry(taskComponent);
+      if (!isKnownSubagentType(subagent_type, registry2)) {
         return {
           success: false,
           output: "",
@@ -616,7 +630,7 @@ async function handleSyncTask(taskComponent, parentSessionId, description, promp
       };
     }
     const agentComponent = taskComponent.env?.getComponent?.("agent");
-    const registry = agentComponent?.getRegistry?.();
+    const registry = getAgentRegistry(taskComponent);
     const resolved = await resolveSubAgentConfig(subagentType, { registry });
     const subAgent = getSubAgentSpec(subagentType);
     let basePrompt = resolved?.basePrompt || subAgent?.promptOverride || `You are a subagent. Complete this task: {task_description}`;

package/dist/shared/@ai-setting/{roy-agent-core-7t05apnp.js → roy-agent-core-fg3j215p.js}

@@ -1,10 +1,17 @@
 import {
   getXDGPath
 } from "./roy-agent-core-qxnbvgwe.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
 import {
   createLogger,
   init_logger
 } from "./roy-agent-core-10n2jh7p.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/agent/agent-registry.ts
 import { readdir, readFile, writeFile, mkdir, unlink } from "fs/promises";
@@ -13,6 +20,7 @@ import { join } from "path";
 import { z } from "zod";
 import yaml from "yaml";
 init_logger();
+init_decorator();
 var logger = createLogger("agent:registry");
 var AgentConfigSchema = z.object({
   name: z.string(),
@@ -262,6 +270,24 @@ class AgentRegistry {
     return join(this.configDir, `${name}.yaml`);
   }
 }
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.register", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "register", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.unregister", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "unregister", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.clear", { recordParams: false, recordResult: true, log: true })
+], AgentRegistry.prototype, "clear", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.getSystemPrompt", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "getSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.load", { recordParams: false, recordResult: true, log: true })
+], AgentRegistry.prototype, "load", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.loadFromDirectory", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "loadFromDirectory", null);
 function isAgentConfigFile(fileName) {
   return fileName.endsWith(".yaml") || fileName.endsWith(".yml");
 }