@ai-setting/roy-agent-core 1.5.43 → 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-7fgf85wc.js → roy-agent-core-h0x19xgn.js}

@@ -132,6 +132,11 @@ class WorkflowConverter {
       retry: meta.retry,
       timeout: meta.timeout
     }));
+    const edges = edgeMetadatas.map((edge) => ({
+      from: edge.from,
+      to: edge.to,
+      when: edge.condition
+    }));
     const entry = workflowMeta.entry || nodeMetadatas[0]?.nodeId || "unknown";
     return {
       name: workflowMeta.name,
@@ -139,6 +144,7 @@ class WorkflowConverter {
       description: workflowMeta.description,
       config: workflowMeta.config || {},
       nodes,
+      edges,
       entry,
       outputs: [],
       metadata: {
@@ -158,13 +164,6 @@ class WorkflowConverter {
         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;