@ai-setting/roy-agent-core 1.7.52 → 1.7.55

package/dist/shared/@ai-setting/{roy-agent-core-x8n1r7h4.js → roy-agent-core-2bscfrr1.js}

@@ -7,6 +7,157 @@ import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
 
+// src/env/workflow/utils/redact-command-secrets.ts
+function replaceTrailing(match, raw) {
+  if (raw.length === 0)
+    return match;
+  const idx = match.lastIndexOf(raw);
+  if (idx < 0)
+    return match;
+  return match.slice(0, idx) + MASK;
+}
+function looksLikeCredentialCommand(command) {
+  return PASSWORD_FLAG_TOOL_RE.test(command);
+}
+function looksLikeShortATool(command) {
+  return SHORT_A_TOOL_RE.test(command);
+}
+function looksLikePasswordValue(value) {
+  if (value.length === 0)
+    return false;
+  if (PATH_LIKE_RE.test(value))
+    return false;
+  if (NUMERIC_RE.test(value))
+    return false;
+  return true;
+}
+function redactCommandSecrets(command) {
+  if (!command)
+    return command;
+  let out = command;
+  out = out.replace(AUTH_SCHEME_RE, (match, prefix, scheme, value) => isMasked(value) ? match : `${prefix}${scheme} ${MASK}`);
+  out = out.replace(URL_USERINFO_RE, (match, head, value, at) => isMasked(value) ? match : `${head}${MASK}${at}`);
+  out = out.replace(URL_QUERY_RE, (match, amp, name, eq, value) => {
+    if (!SENSITIVE_QUERY_KEY_RE.test(name))
+      return match;
+    if (isMasked(value))
+      return match;
+    return `${amp}${name}${eq}${MASK}`;
+  });
+  out = out.replace(SHORT_U_RE, (match, lead, flag, user, pass) => {
+    if (isMasked(pass))
+      return match;
+    const name = user.slice(0, -1);
+    if (UID_GID_RE.test(name) && UID_GID_RE.test(pass))
+      return match;
+    if (name === pass)
+      return match;
+    return `${lead}${flag}${user}${MASK}`;
+  });
+  out = out.replace(LONG_USER_RE, (match, lead, flag, user, pass) => {
+    if (isMasked(pass))
+      return match;
+    const name = user.slice(0, -1);
+    if (UID_GID_RE.test(name) && UID_GID_RE.test(pass))
+      return match;
+    if (name === pass)
+      return match;
+    return `${lead}${flag}${user}${MASK}`;
+  });
+  if (looksLikeCredentialCommand(command)) {
+    const maskPassword = (match, lead, flag, dq, sq, bare) => {
+      const value = dq ?? sq ?? bare ?? "";
+      if (isMasked(value) || !looksLikePasswordValue(value))
+        return match;
+      if (dq !== undefined)
+        return `${lead}${flag}"${MASK}"`;
+      if (sq !== undefined)
+        return `${lead}${flag}'${MASK}'`;
+      return lead + flag + MASK;
+    };
+    out = out.replace(SHORT_P_SPACED_RE, maskPassword);
+    out = out.replace(SHORT_P_ATTACHED_RE, maskPassword);
+  }
+  out = out.replace(AUTH_FAILURE_CRED_RE, (match, head, user, pass) => isMasked(pass) ? match : `${head}${user}:${MASK}`);
+  out = out.replace(AWS_SET_SECRET_RE, (match, key, value) => isMasked(value) ? match : `${key} ${MASK}`);
+  if (looksLikeShortATool(command)) {
+    out = out.replace(SHORT_A_SECRET_RE, (match, lead, flag, value) => isMasked(value) || !looksLikePasswordValue(value) ? match : `${lead}${flag}${MASK}`);
+    out = out.replace(SHORT_A_ATTACHED_RE, (match, lead, flag, value) => isMasked(value) || !looksLikePasswordValue(value) ? match : `${lead}${flag}${MASK}`);
+  }
+  out = out.replace(ASSIGNMENT_RE, (match, key, dq, sq, bare) => {
+    if (!SENSITIVE_KEY_RE.test(key))
+      return match;
+    const value = dq ?? sq ?? bare ?? "";
+    if (value === MASK)
+      return match;
+    const isAuthHeaderKey = /^(?:proxy-)?authorization$/i.test(key);
+    if (isAuthHeaderKey && AUTH_SCHEME_WORD_RE.test(value))
+      return match;
+    const raw = dq !== undefined ? `"${value}"` : sq !== undefined ? `'${value}'` : value;
+    return replaceTrailing(match, raw);
+  });
+  out = out.replace(FLAG_RE, (match, lead, flag, _sep, dq, sq, bare) => {
+    if (!SENSITIVE_KEY_RE.test(flag))
+      return match;
+    const value = dq ?? sq ?? bare ?? "";
+    if (value === MASK)
+      return match;
+    const raw = dq !== undefined ? `"${value}"` : sq !== undefined ? `'${value}'` : value;
+    return replaceTrailing(match, raw);
+  });
+  return out;
+}
+function summarizeCommand(command, maxLen = 120) {
+  if (!command)
+    return "";
+  const collapsed = command.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLen)
+    return collapsed;
+  return `${collapsed.slice(0, maxLen)}…`;
+}
+var MASK = "[REDACTED]", SENSITIVE_KEY_RE, BARE_VALUE = `[^\\s;&|]+[^\\s;&|"'<>()]|[^\\s;&|]`, ASSIGNMENT_RE, FLAG_RE, AUTH_SCHEME_RE, SENSITIVE_QUERY_KEY_RE, URL_QUERY_RE, URL_USERINFO_RE, AUTH_FAILURE_CRED_RE, SHORT_U_RE, LONG_USER_RE, UID_GID_RE, SHORT_P_SPACED_RE, SHORT_P_ATTACHED_RE, isMasked = (value) => (value ?? "").trim() === MASK, AUTH_SCHEME_WORD_RE, PASSWORD_FLAG_TOOL_RE, SHORT_A_TOOL_RE, SHORT_A_SECRET_RE, SHORT_A_ATTACHED_RE, AWS_SET_SECRET_RE, PATH_LIKE_RE, NUMERIC_RE;
+var init_redact_command_secrets = __esm(() => {
+  SENSITIVE_KEY_RE = /(?:pass(?:word|wd|phrase)?|token|secret|api[_-]?key|apikey|credential|authorization|private[_-]?key)/i;
+  ASSIGNMENT_RE = new RegExp(`(?<![A-Za-z0-9_.-])([A-Za-z0-9_][A-Za-z0-9_.-]*)\\s*[=:]\\s*(?:"([^"]*)"|'([^']*)'|(${BARE_VALUE}))`, "g");
+  FLAG_RE = new RegExp(`(^|[\\s])(--?[A-Za-z0-9][A-Za-z0-9_.-]*)(=\\s*|\\s+)(?:"([^"]*)"|'([^']*)'|(${BARE_VALUE}))`, "g");
+  AUTH_SCHEME_RE = new RegExp(`((?:Proxy-)?Authorization["']?\\s*[:=]\\s*["']?\\s*)(Bearer|Basic|Token|Digest)\\s+(${BARE_VALUE}|\\[REDACTED\\])`, "gi");
+  SENSITIVE_QUERY_KEY_RE = new RegExp([
+    "^pass(?:word|wd)?$",
+    "^pwd$",
+    "^token$",
+    "^access[_-]?token$",
+    "^refresh[_-]?token$",
+    "^id[_-]?token$",
+    "^secret$",
+    "^client[_-]?secret$",
+    "^api[_-]?key$",
+    "^apikey$",
+    "^credential$",
+    "^credentials$",
+    "^sig$",
+    "^signature$",
+    "^auth$",
+    "^authorization$",
+    "^private[_-]?key$"
+  ].join("|"), "i");
+  URL_QUERY_RE = /([?&])([A-Za-z_][A-Za-z0-9_.-]*)(=)([^&#\s"']+)/g;
+  URL_USERINFO_RE = /(\/\/[^/\s:@]+:)([^/\s"']+)(@)/g;
+  AUTH_FAILURE_CRED_RE = /(\b(?:auth(?:entication|orization)?|login|credentials?|password|passwd|token)\b[^\n:]{0,40}?[\s"'])([A-Za-z0-9_.-]{1,64}):([^\s;&|"'<>]{3,})/gi;
+  SHORT_U_RE = /(^|\s)(-u\s+)([^:\s]+:)([^\s;&|"']+)/g;
+  LONG_USER_RE = /(^|\s)(--user(?:=|\s+))([^:\s]+:)([^\s;&|"']+)/g;
+  UID_GID_RE = /^\d+$/;
+  SHORT_P_SPACED_RE = new RegExp(`(^|\\s)(-p\\s+)(?:"([^"]*)"|'([^']*)'|(${BARE_VALUE}))`, "g");
+  SHORT_P_ATTACHED_RE = new RegExp(`(^|\\s)(-p)(?:"([^"]*)"|'([^']*)'|(${BARE_VALUE}))`, "g");
+  AUTH_SCHEME_WORD_RE = /^(?:bearer|basic|token|digest|negotiate|ntlm)$/i;
+  PASSWORD_FLAG_TOOL_RE = /(?<![\w/.-])(?:docker\s+login|helm\s+(?:registry\s+)?login|mysql|mysqldump|mariadb|sshpass)\b/i;
+  SHORT_A_TOOL_RE = /(?<![\w/.-])redis-cli\b/i;
+  SHORT_A_SECRET_RE = new RegExp(`(^|\\s)(-a\\s+)(?!-)(${BARE_VALUE})`, "g");
+  SHORT_A_ATTACHED_RE = new RegExp(`(^|\\s)(-a)(${BARE_VALUE})`, "g");
+  AWS_SET_SECRET_RE = new RegExp(`\\b((?:aws[_-])?(?:secret[_-]?access[_-]?key|session[_-]?token))\\s+(?!set\\b)([^=\\s;&|][^\\s;&|]*[^\\s;&|"'<>()]|[^=\\s;&|])`, "gi");
+  PATH_LIKE_RE = /^(?:\/|\.\/|\.\.\/|~\/)/;
+  NUMERIC_RE = /^\d+$/;
+});
+
 // src/env/workflow/nodes/tool-node.ts
 function isPositiveNumber(v) {
   return typeof v === "number" && Number.isFinite(v) && v > 0;
@@ -23,9 +174,39 @@ function getToolTimeoutMs(input, config) {
   }
   return DEFAULT_TOOL_TIMEOUT_MS;
 }
-var DEFAULT_TOOL_TIMEOUT_MS = 60000, ToolNode;
+function redactTail(text, tailChars) {
+  const window = text.length > tailChars + REDACT_TAIL_SLACK ? text.slice(-(tailChars + REDACT_TAIL_SLACK)) : text;
+  return redactCommandSecrets(window).trim().slice(-tailChars).trim();
+}
+function redactErrorForOutput(err) {
+  const message = redactCommandSecrets(err.message);
+  const stack = typeof err.stack === "string" ? redactCommandSecrets(err.stack) : undefined;
+  if (message === err.message && stack === err.stack)
+    return err;
+  const clone = new Error(message, { cause: err });
+  clone.name = err.name;
+  if (stack)
+    clone.stack = stack;
+  return clone;
+}
+function buildExitCodeError(exitCode, md, toolInput) {
+  const parts = [`Tool exited with code ${exitCode}`];
+  const rawCommand = toolInput && typeof toolInput === "object" ? toolInput.command ?? toolInput.cmd : undefined;
+  if (typeof rawCommand === "string" && rawCommand.trim().length > 0) {
+    const safe = summarizeCommand(redactCommandSecrets(rawCommand));
+    if (safe.length > 0) {
+      parts.push(`command: ${safe}`);
+    }
+  }
+  const stdout = typeof md.stdout === "string" ? md.stdout : "";
+  const stdoutTail = redactTail(stdout, 300);
+  parts.push(stdoutTail.length > 0 ? `stdout tail: ${stdoutTail}` : "(no stdout)");
+  return parts.join(" | ");
+}
+var DEFAULT_TOOL_TIMEOUT_MS = 60000, REDACT_TAIL_SLACK = 4096, ToolNode;
 var init_tool_node = __esm(() => {
   init_decorator();
+  init_redact_command_secrets();
   ToolNode = class ToolNode {
     definition;
     toolRegistry;
@@ -125,7 +306,7 @@ var init_tool_node = __esm(() => {
           }
         }
         const extractedOutput = this.extractFromWrapper(output);
-        const wrapperError = this.extractErrorFromWrapper(output);
+        const wrapperError = this.extractErrorFromWrapper(output, input);
         return {
           output: extractedOutput,
           error: wrapperError,
@@ -134,7 +315,7 @@ var init_tool_node = __esm(() => {
       } catch (error) {
         return {
           output: undefined,
-          error: error instanceof Error ? error : new Error(String(error)),
+          error: error instanceof Error ? redactErrorForOutput(error) : new Error(redactCommandSecrets(String(error))),
           durationMs: Date.now() - startTime
         };
       }
@@ -159,7 +340,7 @@ var init_tool_node = __esm(() => {
       }
       return result;
     }
-    extractErrorFromWrapper(value) {
+    extractErrorFromWrapper(value, toolInput) {
       if (value === null || value === undefined) {
         return;
       }
@@ -172,10 +353,10 @@ var init_tool_node = __esm(() => {
       }
       const err = obj.error;
       if (typeof err === "string" && err.length > 0) {
-        return err;
+        return redactCommandSecrets(err);
       }
       if (err instanceof Error) {
-        return err;
+        return redactErrorForOutput(err);
       }
       const md = obj.metadata;
       if (md) {
@@ -185,7 +366,7 @@ var init_tool_node = __esm(() => {
         }
         if (typeof md.exit_code === "number" && md.exit_code !== 0) {
           const stderr = typeof md.stderr === "string" ? md.stderr : "";
-          return stderr.length > 0 ? stderr : `Tool exited with code ${md.exit_code}`;
+          return stderr.length > 0 ? redactCommandSecrets(stderr) : buildExitCodeError(md.exit_code, md, toolInput);
         }
       }
       return `Tool execution failed (success=false, no error message)`;

package/dist/shared/@ai-setting/{roy-agent-core-gdsqp6j8.js → roy-agent-core-6masakz4.js}

@@ -1548,6 +1548,28 @@ workflow-creator 是**多轮对话式**协作。每个阶段都可能需要 ask
 - ❌ **禁止**对 \`tool\` 节点写深层路径（如 \`{{nodes.bash-node.output.foo}}\`）—— tool 输出常是字符串，无法再取属性
 - ✅ 存疑时一律退回 \`.output\`，或用 \`{{nodes.X.output}}\` 打印后**人肉核对**
 
+### 阶段 4.6: 单节点冒烟前置 (Per-node Standalone Smoke) \uD83E\uDDEA
+
+> **依据 Task #4385 §3.4**：历史失败中，大量节点是**在整条 workflow 里第一次被执行**的 ——
+> 脚本名拼错、产物目录不存在、命令依赖 \`cd\`、参数没传进去…… 一个坏节点就烧掉整轮 run，
+> 然后你在整条链路的噪音里排障。**先把每个节点单独跑通，再拼成 DAG。**
+
+**在把 YAML 组装/注册之前，对每一个 \`tool\` / \`pythonCall\` / \`skill\` 节点逐个做单节点冒烟：**
+
+1. 用 \`bash\` 把该节点的 \`config.command\`（或 \`config.script\` / \`args\`）**原样**执行一次。
+   - 变量先替换成真实值再跑（不要留着 \`{{input.x}}\` 跑，那验不出东西）
+   - 逐个节点跑，**不是**跑整条链路
+2. 三项全绿才算该节点通过：
+   - ✅ **exit code = 0**（非 0 立刻停下修，不要往后拼）
+   - ✅ **产物/目录真实存在**（脚本声称会写出的文件、目录、wheel、日志，用 \`ls\` 核实）
+   - ✅ **输出非空且含预期标记**（\`grep\` 你后面要引用的那个标记，命中才算通）
+3. 任何一项红了 → **先修这个节点**（改路径 / 改命令 / 改脚本），修好重跑，**不要**带着红灯继续组装。
+
+**为什么不能省**：\`workflow_validate\` 只校验 DAG 结构 + 模板引用契约，它**看不到**
+"这个 shell 命令在这个 cwd 下到底能不能跑通"。单节点冒烟是唯一廉价、快速、可重复的补位。
+
+**通过后**记录一张自检表（节点 id → exit code / 产物 / 标记），写进最终报告。
+
 ### 阶段 5: 迭代验证 (Iterative Validate) \uD83D\uDD01
 
 调用 \`workflow_validate\`，它返回 \`{ valid, errors, warnings, infos, errorCount, warningCount }\`。
@@ -1601,6 +1623,29 @@ workflow-creator 是**多轮对话式**协作。每个阶段都可能需要 ask
 **未通过冒烟 → 禁止 \`task_complete\`**：回到阶段 4 改 YAML，重跑，直到通过；或明确报告失败原因
 （**不得**用"应该没问题"之类的措辞声称通过）。
 
+#### \uD83D\uDEAB 手动补跑 ≠ 真跑（依据 Task #4385 §3.5）
+
+workflow run 失败后，**手动**把某个节点的命令再敲一遍、看到它成功了，**不算**该节点被验证。
+
+- ❌ 手动补跑的结果**不得计入** PASS 计数，也**不得**作为 "节点没问题" 的依据
+- ❌ 不得因为"手动跑通了"就跳过修 YAML / 重跑 workflow
+- ✅ 手动作业只能用来**定位原因**；结论必须靠**重跑 workflow** 得出
+- ✅ 若最终确实没能在 workflow 内验证某节点，结论里必须显式标注
+  **「⚠️ 该节点未经 workflow run 验证」**，与真正通过的节点分开列
+
+> 为什么：手动跑不经过模板解析、依赖排序、引擎超时与 fail-fast。
+> 一条在 shell 里通的命令，在节点里完全可能因为 \`{{}}\` 解析成空串而"成功但空转"。
+
+#### \uD83D\uDD0D 归因：先分清「超时」与「别的节点先 fail-fast」（依据 Task #4385 §5）
+
+说"某个节点超时了"之前，**必须先证明没有其他节点先失败**。
+
+- 引擎是 **fail-fast** 的：任一节点失败会立刻收尾整个 run，**尚未跑完的节点看起来就像"卡住/超时"**
+- 因此**先排除**：\`roy-agent debug trace <trace_id>\` 里是否已有**其它节点**的失败 span / error
+- 只有在确认 "无其它节点先失败" 之后，才可以判断为真超时，再去看该节点自己的 span 耗时与 stdout
+- ❌ 不要把 fail-fast 的连带中止当成超时去"修超时参数" —— 这会让你在错误的节点上白改几轮
+  （历史教训：#4361 / #4366 连续两轮误判）
+
 > \uD83D\uDEAB **绝不允许用 \`workflow update\` 绕过冒烟验证**（历史上真实节点版本 v1.1.0/v1.2.0 就是走
 > \`workflow update\` 注册的，完全绕过了 validate 与冒烟）。update 后**同样必须**重跑阶段 5 + 5.5。
 

package/dist/shared/@ai-setting/{roy-agent-core-vvxb9522.js → roy-agent-core-6qxh4xrm.js}

@@ -1,13 +1,13 @@
 import {
   isValidSessionId
-} from "./roy-agent-core-yd21n6c7.js";
+} from "./roy-agent-core-zvemdfx5.js";
 import {
   TAG_MAX_COUNT,
   TAG_MIN_COUNT
 } from "./roy-agent-core-7evvpfwc.js";
 import {
   validateWorkflowDefinition
-} from "./roy-agent-core-na73mym1.js";
+} from "./roy-agent-core-a4vzsn0g.js";
 import {
   getCurrentBgTaskId
 } from "./roy-agent-core-c1v263jn.js";
@@ -24,7 +24,8 @@ import {
   init_logger
 } from "./roy-agent-core-8seq65bp.js";
 import {
-  __legacyDecorateClassTS
+  __legacyDecorateClassTS,
+  __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/tools/ask-user-tool.ts
@@ -480,8 +481,25 @@ var logger5 = createLogger("workflow-validate-tool");
 var WorkflowValidateInputSchema = z6.object({
   definition: z6.any().optional().describe("Workflow definition object (alternative to definition_yaml)"),
   definition_yaml: z6.string().optional().describe("Workflow definition as YAML or JSON string"),
-  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string")
+  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string"),
+  file: z6.string().optional().describe("Path to a YAML/JSON file to validate. Use this INSTEAD of passing " + "`$(cat /path)` — shell substitutions are NOT expanded by this tool.")
 });
+function isAllowedPath(absPath) {
+  const cwd = process.cwd();
+  const normalized = absPath.replace(/\\/g, "/");
+  if (normalized === cwd || normalized.startsWith(`${cwd}/`))
+    return true;
+  if (normalized === "/tmp" || normalized.startsWith("/tmp/"))
+    return true;
+  return false;
+}
+function detectShellSubstitution(text) {
+  const trimmed = text.trim();
+  const looksLikeSubstitution = /^\$\(.*\)$/.test(trimmed) || /^`.*`$/.test(trimmed) || /\$\(\s*cat\s+/.test(trimmed) || /`\s*cat\s+/.test(trimmed);
+  if (!looksLikeSubstitution)
+    return;
+  return "Shell substitutions such as `$(cat /path)` are NOT expanded by this tool — the " + "string is passed to the YAML parser verbatim, which is why you saw " + "`Parsed definition is not an object`. Pass the path directly instead: " + 'workflow_validate({ file: "/tmp/x.yaml" }).';
+}
 function createWorkflowValidateTool(_workflowService) {
   return {
     name: "workflow_validate",
@@ -493,13 +511,56 @@ function createWorkflowValidateTool(_workflowService) {
         let definition;
         if (params.definition && typeof params.definition === "object") {
           definition = params.definition;
+        } else if (params.file && typeof params.file === "string") {
+          const fs = await import("node:fs/promises");
+          const nodePath = await import("node:path");
+          const abs = nodePath.resolve(params.file);
+          if (!isAllowedPath(abs)) {
+            return {
+              success: false,
+              output: "",
+              error: `Refusing to read outside the working directory or /tmp: ${abs}. Copy the file into CWD or /tmp first.`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          let raw;
+          try {
+            raw = await fs.readFile(abs, "utf-8");
+          } catch (readErr) {
+            const code = readErr?.code;
+            return {
+              success: false,
+              output: "",
+              error: code === "ENOENT" ? `Workflow file not found: ${abs}. Check the path (it is resolved against CWD: ${process.cwd()}).` : `Failed to read workflow file ${abs}: ${readErr instanceof Error ? readErr.message : String(readErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          try {
+            definition = yaml2.parse(raw);
+          } catch (yamlErr) {
+            return {
+              success: false,
+              output: "",
+              error: `Invalid YAML in ${abs}: ${yamlErr instanceof Error ? yamlErr.message : String(yamlErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
         } else {
           const yamlText = params.yaml ?? params.definition_yaml;
           if (!yamlText || typeof yamlText !== "string") {
             return {
               success: false,
               output: "",
-              error: "Must provide either 'definition' (object), 'definition_yaml', or 'yaml' (string)",
+              error: "Must provide either 'definition' (object), 'file' (path), 'definition_yaml', or 'yaml' (string)",
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          const substitutionHint = detectShellSubstitution(yamlText);
+          if (substitutionHint) {
+            return {
+              success: false,
+              output: "",
+              error: substitutionHint,
               metadata: { execution_time_ms: 0 }
             };
           }
@@ -518,7 +579,7 @@ function createWorkflowValidateTool(_workflowService) {
           return {
             success: false,
             output: "",
-            error: "Parsed definition is not an object",
+            error: `Parsed definition is not an object (got ${definition === null ? "null" : typeof definition}). If you passed a file path as a string, use workflow_validate({ file: "/path/to.yaml" }) ` + "instead of embedding `$(cat ...)` — shell substitutions are not expanded here.",
             metadata: { execution_time_ms: 0 }
           };
         }

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

@@ -1,9 +1,9 @@
 import {
   SessionMessageConverter
-} from "./roy-agent-core-pk1b3kvf.js";
+} from "./roy-agent-core-2b8jtv7m.js";
 import {
   canonicalizeParts
-} from "./roy-agent-core-zy3hqfwg.js";
+} from "./roy-agent-core-0hq21px2.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-s214vmmd.js → roy-agent-core-8eqngasy.js}

@@ -13,7 +13,7 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-vvxb9522.js";
+} from "./roy-agent-core-6qxh4xrm.js";
 import {
   WorkflowService
 } from "./roy-agent-core-7evvpfwc.js";
@@ -21,7 +21,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-35s1w7tc.js";
+} from "./roy-agent-core-aer5kw1j.js";
 import {
   BaseComponent
 } from "./roy-agent-core-tdbv7ff4.js";

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

@@ -1,7 +1,7 @@
 import {
   LarkCardPatchNotifier,
   formatDurationMs
-} from "./roy-agent-core-j8e92gj8.js";
+} from "./roy-agent-core-b5ew8t0k.js";
 import {
   WorkflowHookPoints,
   init_workflow_hook_points