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

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

@@ -0,0 +1,435 @@
+import {
+  init_types,
+  nodeNotFound,
+  pathNotFound,
+  unresolvedVariable
+} from "./roy-agent-core-qnrf2aw6.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  __esm,
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/utils/template-resolver.ts
+function resolveTemplates(input, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveValue(input);
+}
+function resolveTemplateString(template, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveString(template);
+}
+var TemplateResolver;
+var init_template_resolver = __esm(() => {
+  init_decorator();
+  init_types();
+  TemplateResolver = class TemplateResolver {
+    input;
+    previousOutputs;
+    constructor(options = {}) {
+      this.input = options.input ?? {};
+      this.previousOutputs = options.previousOutputs ?? new Map;
+    }
+    static fromContext(context) {
+      return new TemplateResolver({
+        input: context.workflowInput ?? context.input,
+        previousOutputs: context.previousOutputs
+      });
+    }
+    resolveValue(input) {
+      if (input === null || input === undefined) {
+        return input;
+      }
+      if (typeof input === "string") {
+        const pureTemplate = this.extractPureTemplate(input);
+        if (pureTemplate) {
+          return this.resolvePureTemplate(pureTemplate);
+        }
+        return this.resolveString(input);
+      }
+      if (Array.isArray(input)) {
+        return input.map((item) => this.resolveValue(item));
+      }
+      if (typeof input === "object") {
+        const resolved = {};
+        for (const [key, value] of Object.entries(input)) {
+          resolved[key] = this.resolveValue(value);
+        }
+        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) {
+      const value = this.resolveTemplateContent(templateContent);
+      return value;
+    }
+    resolveTemplateContent(templateContent) {
+      const trimmed = templateContent.trim();
+      if (trimmed.startsWith("input.")) {
+        return this.getNestedValue(this.input, trimmed.slice(6));
+      }
+      if (trimmed.startsWith("inputs.")) {
+        return this.getNestedValue(this.input, trimmed.slice(7));
+      }
+      if (trimmed.startsWith("nodes.")) {
+        return this.resolveNodePath(trimmed.slice(6));
+      }
+      if (trimmed !== "input" && trimmed !== "inputs" && trimmed !== "nodes") {
+        const segments = trimmed.split(".");
+        const nodeId = segments[0];
+        const restPath = segments.slice(1).join(".") || undefined;
+        return this.resolveNodePath(`${nodeId}${restPath ? "." + restPath : ""}`);
+      }
+      return;
+    }
+    resolveString(template) {
+      if (!template || typeof template !== "string") {
+        return template;
+      }
+      let resolved = template;
+      resolved = resolved.replace(/\{\{inputs\./g, "{{input.");
+      resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+        const value = this.getNestedValue(this.input, path);
+        return this.stringify(value, match);
+      });
+      resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+        const value = this.resolveNodePath(path);
+        return this.stringify(value, match);
+      });
+      resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_-]*)(?:\.([^}]+))?\}\}/g, (match, nodeId, path) => {
+        if (nodeId === "input") {
+          return match;
+        }
+        if (nodeId === "nodes") {
+          return match;
+        }
+        const value = this.resolveNodePath(`${nodeId}${path ? "." + path : ""}`);
+        return this.stringify(value, match);
+      });
+      return resolved;
+    }
+    resolveNodePath(path) {
+      const segments = path.split(".");
+      const nodeId = segments[0];
+      if (!nodeId) {
+        return;
+      }
+      let value = this.previousOutputs.get(nodeId);
+      if (value === undefined) {
+        const normalizedUnderscore = nodeId.replace(/-/g, "_");
+        const normalizedHyphen = nodeId.replace(/_/g, "-");
+        if (normalizedUnderscore !== nodeId) {
+          value = this.previousOutputs.get(normalizedUnderscore);
+        }
+        if (value === undefined && normalizedHyphen !== nodeId) {
+          value = this.previousOutputs.get(normalizedHyphen);
+        }
+      }
+      if (value === undefined) {
+        return;
+      }
+      if (segments.length === 1) {
+        if (value && typeof value === "object" && "result" in value && !("nodes" in value)) {
+          value = value.result;
+        }
+        return value;
+      }
+      const secondSegment = segments[1];
+      if (secondSegment === "result" || secondSegment === "output") {
+        if (value && typeof value === "object" && "result" in value) {
+          value = value.result;
+          if (segments.length === 2) {
+            return value;
+          }
+          for (let i = 2;i < segments.length; i++) {
+            if (value === null || value === undefined) {
+              return;
+            }
+            value = value[segments[i]];
+          }
+          return value;
+        }
+      }
+      for (let i = 1;i < segments.length; i++) {
+        if (value === null || value === undefined) {
+          return;
+        }
+        value = value[segments[i]];
+      }
+      return value;
+    }
+    getNestedValue(obj, path) {
+      if (!obj || !path) {
+        return;
+      }
+      const segments = path.split(".");
+      let current = obj;
+      for (const segment of segments) {
+        if (current === null || current === undefined) {
+          return;
+        }
+        if (typeof current !== "object") {
+          return;
+        }
+        current = current[segment];
+      }
+      return current;
+    }
+    stringify(value, originalTemplate) {
+      if (value === undefined) {
+        return originalTemplate;
+      }
+      if (typeof value === "string") {
+        return value;
+      }
+      if (value === null) {
+        return "null";
+      }
+      return JSON.stringify(value);
+    }
+    containsTemplates(str) {
+      if (typeof str !== "string") {
+        return false;
+      }
+      return /\{\{[^}]+\}\}/.test(str);
+    }
+    extractTemplates(str) {
+      if (typeof str !== "string") {
+        return [];
+      }
+      const matches = str.match(/\{\{[^}]+\}\}/g);
+      return matches ?? [];
+    }
+    resolveAndValidate(input) {
+      const unresolved = [];
+      const resolved = this.resolveValueWithTracking(input, unresolved);
+      return { resolved, unresolved };
+    }
+    resolveValueWithTracking(input, unresolved) {
+      if (input === null || input === undefined) {
+        return input;
+      }
+      if (typeof input === "string") {
+        const pureTemplate = this.extractPureTemplate(input);
+        if (pureTemplate) {
+          const value = this.resolvePureTemplate(pureTemplate);
+          if (value === undefined) {
+            unresolved.push(input);
+            return input;
+          }
+          return value;
+        }
+        return this.resolveStringWithTracking(input, unresolved);
+      }
+      if (Array.isArray(input)) {
+        return input.map((item) => this.resolveValueWithTracking(item, unresolved));
+      }
+      if (typeof input === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+          result[key] = this.resolveValueWithTracking(value, unresolved);
+        }
+        return result;
+      }
+      return input;
+    }
+    resolveStringWithTracking(str, unresolved) {
+      const templates = this.extractTemplates(str);
+      let resolved = str;
+      for (const template of templates) {
+        const pureContent = template.slice(2, -2).trim();
+        const value = this.resolveTemplateContent(pureContent);
+        if (value === undefined) {
+          unresolved.push(template);
+        } else {
+          const resolvedValue = this.stringify(value, template);
+          resolved = resolved.replace(template, resolvedValue);
+        }
+      }
+      return resolved;
+    }
+    resolveStrict(input, nodeId) {
+      const result = this.resolveAndValidate(input);
+      if (result.unresolved.length > 0) {
+        for (const template of result.unresolved) {
+          const path = template.replace(/^\{\{|\}\}$/g, "");
+          if (path.startsWith("input.")) {
+            const inputKey = path.slice(6);
+            const value = this.getNestedValue(this.input, inputKey);
+            if (value === undefined) {
+              throw unresolvedVariable(template, inputKey);
+            }
+            continue;
+          }
+          if (path.startsWith("inputs.")) {
+            const inputKey = path.slice(7);
+            const value = this.getNestedValue(this.input, inputKey);
+            if (value === undefined) {
+              throw unresolvedVariable(template, inputKey);
+            }
+            continue;
+          }
+          if (path.startsWith("nodes.")) {
+            const afterPrefix = path.slice(6);
+            const nodeParts = afterPrefix.split(".");
+            const refNodeId = nodeParts[0];
+            if (!this.previousOutputs.has(refNodeId)) {
+              throw nodeNotFound(refNodeId, [template]);
+            }
+            if (nodeParts.length > 1) {
+              const refPath = nodeParts.slice(1).join(".");
+              const nodeValue = this.previousOutputs.get(refNodeId);
+              const nestedValue = this.getNestedValue(nodeValue, refPath);
+              if (nestedValue === undefined) {
+                throw pathNotFound(refNodeId, refPath, template);
+              }
+            }
+            continue;
+          }
+          if (path.includes(".")) {
+            const [refNodeId, ...pathParts] = path.split(".");
+            if (this.previousOutputs.has(refNodeId)) {
+              const refPath = pathParts.join(".");
+              const nodeValue = this.previousOutputs.get(refNodeId);
+              const nestedValue = this.getNestedValue(nodeValue, refPath);
+              if (nestedValue === undefined) {
+                throw pathNotFound(refNodeId, refPath, template);
+              }
+            } else {
+              throw nodeNotFound(refNodeId, [template]);
+            }
+          } else {
+            if (!this.previousOutputs.has(path)) {
+              throw nodeNotFound(path, [template]);
+            }
+          }
+        }
+        throw unresolvedVariable(result.unresolved[0], result.unresolved.join(", "));
+      }
+      return result.resolved;
+    }
+    evaluateCondition(condition) {
+      const resolved = this.resolveString(condition);
+      return this.parseCondition(resolved);
+    }
+    parseCondition(condition) {
+      const expr = condition.trim();
+      if (expr === "true")
+        return true;
+      if (expr === "false")
+        return false;
+      if (expr.startsWith("!")) {
+        return !this.parseCondition(expr.slice(1).trim());
+      }
+      const orParts = this.splitByOperator(expr, "||");
+      if (orParts.length > 1) {
+        return orParts.some((p) => this.parseCondition(p.trim()));
+      }
+      const andParts = this.splitByOperator(expr, "&&");
+      if (andParts.length > 1) {
+        return andParts.every((p) => this.parseCondition(p.trim()));
+      }
+      const comparisonPatterns = [
+        { pattern: /^(.+)\s*===\s*(.+)$/, op: "===" },
+        { pattern: /^(.+)\s*!==\s*(.+)$/, op: "!==" },
+        { pattern: /^(.+)\s*==\s*(.+)$/, op: "==" },
+        { pattern: /^(.+)\s*!=\s*(.+)$/, op: "!=" },
+        { pattern: /^(.+)\s*>=\s*(.+)$/, op: ">=" },
+        { pattern: /^(.+)\s*<=\s*(.+)$/, op: "<=" },
+        { pattern: /^(.+)\s*>\s*(.+)$/, op: ">" },
+        { pattern: /^(.+)\s*<\s*(.+)$/, op: "<" }
+      ];
+      for (const { pattern, op } of comparisonPatterns) {
+        const match = expr.match(pattern);
+        if (match) {
+          const left = this.evaluateValue(match[1].trim());
+          const right = this.evaluateValue(match[2].trim());
+          return this.compare(left, right, op);
+        }
+      }
+      return Boolean(this.evaluateValue(expr));
+    }
+    splitByOperator(expr, op) {
+      const parts = [];
+      let current = "";
+      let inQuotes = null;
+      for (let i = 0;i < expr.length; i++) {
+        const char = expr[i];
+        if (char === '"' || char === "'") {
+          if (inQuotes === char) {
+            inQuotes = null;
+          } else if (inQuotes === null) {
+            inQuotes = char;
+          }
+          current += char;
+        } else if (inQuotes) {
+          current += char;
+        } else if (expr.slice(i, i + op.length) === op) {
+          parts.push(current);
+          current = "";
+          i += op.length - 1;
+        } else {
+          current += char;
+        }
+      }
+      if (current) {
+        parts.push(current);
+      }
+      return parts;
+    }
+    evaluateValue(value) {
+      const v = value.trim();
+      if (v === "true")
+        return true;
+      if (v === "false")
+        return false;
+      if (!isNaN(Number(v)))
+        return Number(v);
+      if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+        return v.slice(1, -1);
+      }
+      return v;
+    }
+    compare(left, right, op) {
+      switch (op) {
+        case "===":
+        case "==":
+          return left === right;
+        case "!==":
+        case "!=":
+          return left !== right;
+        case ">":
+          return Number(left) > Number(right);
+        case "<":
+          return Number(left) < Number(right);
+        case ">=":
+          return Number(left) >= Number(right);
+        case "<=":
+          return Number(left) <= Number(right);
+        default:
+          return false;
+      }
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.template.resolveAndValidate", { log: true })
+  ], TemplateResolver.prototype, "resolveAndValidate", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.template.resolveStrict", { log: true })
+  ], TemplateResolver.prototype, "resolveStrict", null);
+});
+
+export { TemplateResolver, resolveTemplates, resolveTemplateString, init_template_resolver };

package/dist/shared/@ai-setting/{roy-agent-core-rsybkb38.js → roy-agent-core-ysvh8er9.js}

@@ -287,16 +287,13 @@ var bashTool = {
 };
 
 // src/env/tool/built-in/echo.ts
+import { z as z2 } from "zod";
 var echoTool = {
   name: "echo",
   description: "Echo a message to the console. Useful for logging in workflows.",
-  parameters: {
-    name: "message",
-    schema: {
-      type: "string",
-      description: "The message to echo"
-    }
-  },
+  parameters: z2.object({
+    message: z2.string().optional().describe("The message to echo")
+  }),
   execute: async (args, _ctx) => {
     const message = args?.message || "(no message)";
     return {
@@ -310,18 +307,18 @@ var echoTool = {
 };
 
 // src/env/tool/built-in/glob.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import { glob as globAsync } from "glob";
 import { stat } from "fs/promises";
 import path from "path";
 var globTool = {
   name: "glob",
   description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
-  parameters: z2.object({
-    pattern: z2.string().min(1).describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
-    cwd: z2.string().optional().describe("Working directory to search in"),
-    maxResults: z2.number().int().positive().default(100).optional().describe("Maximum number of results to return"),
-    ignore: z2.array(z2.string()).optional().describe("Patterns to ignore")
+  parameters: z3.object({
+    pattern: z3.string().min(1).describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
+    cwd: z3.string().optional().describe("Working directory to search in"),
+    maxResults: z3.number().int().positive().default(100).optional().describe("Maximum number of results to return"),
+    ignore: z3.array(z3.string()).optional().describe("Patterns to ignore")
   }),
   sandbox: {
     enabled: true
@@ -415,17 +412,17 @@ var globTool = {
 };
 
 // src/env/tool/built-in/read-file.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 import { readFile, stat as stat2 } from "fs/promises";
 import path2 from "path";
 var readFileTool = {
   name: "read_file",
   description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
-  parameters: z3.object({
-    path: z3.string().describe("The file path to read"),
-    offset: z3.number().int().nonnegative().optional().describe("Line offset to start reading from"),
-    limit: z3.number().int().positive().optional().describe("Number of lines to read"),
-    encoding: z3.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding")
+  parameters: z4.object({
+    path: z4.string().describe("The file path to read"),
+    offset: z4.number().int().nonnegative().optional().describe("Line offset to start reading from"),
+    limit: z4.number().int().positive().optional().describe("Number of lines to read"),
+    encoding: z4.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding")
   }),
   sandbox: {
     enabled: true,
@@ -530,17 +527,17 @@ var readFileTool = {
 };
 
 // src/env/tool/built-in/write-file.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import { writeFile, mkdir, stat as stat3 } from "fs/promises";
 import path3 from "path";
 var writeFileTool = {
   name: "write_file",
   description: "Write content to a file. Use this to create new files or overwrite existing ones.",
-  parameters: z4.object({
-    path: z4.string().describe("The file path to write to"),
-    content: z4.string().describe("The content to write"),
-    createDirs: z4.boolean().default(false).optional().describe("Create parent directories if they don't exist"),
-    append: z4.boolean().default(false).optional().describe("Append to file instead of overwrite")
+  parameters: z5.object({
+    path: z5.string().describe("The file path to write to"),
+    content: z5.string().describe("The content to write"),
+    createDirs: z5.boolean().default(false).optional().describe("Create parent directories if they don't exist"),
+    append: z5.boolean().default(false).optional().describe("Append to file instead of overwrite")
   }),
   sandbox: {
     enabled: true,
@@ -620,18 +617,18 @@ var writeFileTool = {
 };
 
 // src/env/tool/built-in/edit-file.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { readFile as readFile2, writeFile as writeFile2, stat as stat4, unlink } from "fs/promises";
 import path4 from "path";
 import { randomUUID } from "crypto";
 var editFileTool = {
   name: "edit_file",
   description: "Edit a file by replacing specific text. Use this to make targeted changes to files by specifying what to find and what to replace.",
-  parameters: z5.object({
-    path: z5.string().describe("The file path to edit"),
-    oldString: z5.string().describe("The text to find and replace"),
-    newString: z5.string().describe("The replacement text"),
-    replaceAll: z5.boolean().default(false).optional().describe("Replace all occurrences instead of just the first")
+  parameters: z6.object({
+    path: z6.string().describe("The file path to edit"),
+    oldString: z6.string().describe("The text to find and replace"),
+    newString: z6.string().describe("The replacement text"),
+    replaceAll: z6.boolean().default(false).optional().describe("Replace all occurrences instead of just the first")
   }),
   sandbox: {
     enabled: true,
@@ -736,7 +733,7 @@ function escapeRegExp(string) {
 }
 
 // src/env/tool/built-in/grep.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { readFile as readFile3, stat as stat5 } from "fs/promises";
 import { glob as globAsync2 } from "glob";
 import path5 from "path";
@@ -751,13 +748,13 @@ function isBinaryContent(content) {
 var grepTool = {
   name: "grep",
   description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
-  parameters: z6.object({
-    pattern: z6.string().min(1).describe("The pattern to search for"),
-    path: z6.string().optional().describe("File or directory path to search in"),
-    include: z6.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
-    caseSensitive: z6.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
-    maxResults: z6.number().int().positive().default(50).optional().describe("Maximum number of results"),
-    showLineNumbers: z6.boolean().default(true).optional().describe("Show line numbers in results")
+  parameters: z7.object({
+    pattern: z7.string().min(1).describe("The pattern to search for"),
+    path: z7.string().optional().describe("File or directory path to search in"),
+    include: z7.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
+    caseSensitive: z7.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
+    maxResults: z7.number().int().positive().default(50).optional().describe("Maximum number of results"),
+    showLineNumbers: z7.boolean().default(true).optional().describe("Show line numbers in results")
   }),
   sandbox: {
     enabled: true

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

@@ -3,8 +3,12 @@ import {
   hasDecoratorNodes,
   init_node_registry_helper,
   registerDecoratorNodeType
-} from "./roy-agent-core-0rtxwr28.js";
+} from "./roy-agent-core-9bmtxmp6.js";
 import"./roy-agent-core-1ce3fqrk.js";
+import"./roy-agent-core-q5qj0fes.js";
+import"./roy-agent-core-10n2jh7p.js";
+import"./roy-agent-core-58k274fg.js";
+import"./roy-agent-core-c6592r3c.js";
 import"./roy-agent-core-fs0mn2jk.js";
 init_node_registry_helper();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.42",
+  "version": "1.5.44",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",