@ai-setting/roy-agent-core 1.7.77 → 1.7.88

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

@@ -0,0 +1,380 @@
+import {
+  buildWecomSendCardFrame
+} from "./roy-agent-core-c4ec7k0p.js";
+import {
+  getEnvContextOrEmpty,
+  init_env_context
+} from "./roy-agent-core-p31ftgq9.js";
+
+// src/env/event-source/wecom-respond-registry.ts
+init_env_context();
+import { z } from "zod";
+
+// src/env/event-source/wecom-cli-sender.ts
+import { spawn } from "child_process";
+var WECOM_CLI_SEND_TIMEOUT_MS = 15000;
+var WECOM_CLI_RESOLVE_TIMEOUT_MS = 15000;
+function resolveWecomCliBinary() {
+  const fromEnv = process.env.WECOM_CLI_BIN;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv.trim();
+  }
+  return "wecom-cli";
+}
+function buildWecomCliSendArgs(input) {
+  return [
+    "message",
+    "aibot",
+    "send",
+    "--chat-id",
+    input.chatId,
+    "--msg-type",
+    "markdown",
+    "--markdown",
+    JSON.stringify({ content: input.content })
+  ];
+}
+function buildWecomCliResolveArgs(keywords) {
+  return ["contact", "users", "search", "--set", `keywords=${keywords}`];
+}
+function parseWecomCliResult(stdout) {
+  const text = (stdout ?? "").trim();
+  if (!text)
+    return { ok: false, error: "empty stdout" };
+  const start = text.indexOf("{");
+  const jsonText = start >= 0 ? text.slice(start) : text;
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return { ok: false, error: `non-JSON stdout: ${text.slice(0, 200)}` };
+  }
+  const obj = parsed;
+  if (obj?.error) {
+    const code = obj.error.code ?? "?";
+    const message = obj.error.message ?? obj.error.type ?? "unknown error";
+    return { ok: false, error: `[code=${code}] ${message}` };
+  }
+  if (obj?.success === true)
+    return { ok: true };
+  return { ok: true };
+}
+function parseWecomCliUserSearch(stdout, fallback) {
+  const text = (stdout ?? "").trim();
+  const start = text.indexOf("{");
+  if (start < 0)
+    return fallback;
+  try {
+    const parsed = JSON.parse(text.slice(start));
+    const userid = parsed?.users?.[0]?.userid;
+    return typeof userid === "string" && userid.length > 0 ? userid : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function runCli(args, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    const finish = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code });
+    };
+    let proc;
+    try {
+      proc = spawn(resolveWecomCliBinary(), args, {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      resolve({
+        stdout: "",
+        stderr: err instanceof Error ? err.message : String(err),
+        code: null
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      finish(null);
+    }, timeoutMs);
+    timer.unref?.();
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("error", (err) => {
+      stderr += err.message;
+      finish(null);
+    });
+    proc.on("close", (code) => finish(code));
+  });
+}
+var cliChatIdCache = new Map;
+async function resolveWecomCliChatId(userId) {
+  const key = userId.trim();
+  if (!key)
+    return key;
+  const cached = cliChatIdCache.get(key);
+  if (cached)
+    return cached;
+  const { stdout } = await runCli(buildWecomCliResolveArgs(key), WECOM_CLI_RESOLVE_TIMEOUT_MS);
+  const resolved = parseWecomCliUserSearch(stdout, key);
+  if (resolved !== key)
+    cliChatIdCache.set(key, resolved);
+  return resolved;
+}
+async function sendWecomCliMarkdown(input) {
+  const content = input.content ?? "";
+  if (!input.chatId || content.trim().length === 0) {
+    return { ok: false, error: "empty chatId or content" };
+  }
+  const { stdout, stderr, code } = await runCli(buildWecomCliSendArgs({ chatId: input.chatId, content }), input.timeoutMs ?? WECOM_CLI_SEND_TIMEOUT_MS);
+  const parsed = parseWecomCliResult(stdout);
+  if (parsed.ok)
+    return parsed;
+  const detail = stderr.trim() ? `${parsed.error} | stderr: ${stderr.trim().slice(0, 200)}` : parsed.error;
+  return { ok: false, error: `${detail} (exit=${code ?? "null"})` };
+}
+
+// src/env/event-source/wecom-respond-registry.ts
+var registry = new Map;
+function registerWecomRespondTarget(sourceId, target) {
+  registry.set(sourceId, target);
+}
+function unregisterWecomRespondTarget(sourceId) {
+  registry.delete(sourceId);
+}
+function getWecomRespondTarget(sourceId) {
+  return registry.get(sourceId);
+}
+function __resetWecomRespondRegistryForTest() {
+  registry.clear();
+}
+async function sendWecomReply(input) {
+  const content = input.content ?? "";
+  if (content.trim().length === 0) {
+    return { ok: false, error: "empty content" };
+  }
+  const errors = [];
+  if (input.reqId) {
+    const target = getWecomRespondTarget(input.sourceId);
+    if (target) {
+      const wsErr = target.respond(input.reqId, {
+        msgtype: "markdown",
+        markdown: { content }
+      });
+      if (!wsErr)
+        return { ok: true, channel: "ws" };
+      errors.push(`ws: ${wsErr.message}`);
+    } else {
+      errors.push(`ws: no instance registered for sourceId=${input.sourceId}`);
+    }
+  } else {
+    errors.push("ws: no req_id");
+  }
+  if (input.rawChatId) {
+    try {
+      const chatId = await resolveWecomCliChatId(input.rawChatId);
+      const cliResult = await sendWecomCliMarkdown({ chatId, content });
+      if (cliResult.ok)
+        return { ok: true, channel: "cli" };
+      errors.push(`cli: ${cliResult.error}`);
+    } catch (err) {
+      errors.push(`cli: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } else {
+    errors.push("cli: no chatId");
+  }
+  return { ok: false, error: errors.join(" | ") };
+}
+async function sendWecomTemplateCard(input) {
+  if (!input.chatId) {
+    return { ok: false, error: "no chatId" };
+  }
+  const target = getWecomRespondTarget(input.sourceId);
+  if (!target) {
+    return {
+      ok: false,
+      error: `no instance registered for sourceId=${input.sourceId}`
+    };
+  }
+  if (typeof target.sendCmd !== "function") {
+    return {
+      ok: false,
+      error: `registered instance has no sendCmd (old bridge?)`
+    };
+  }
+  const frame = buildWecomSendCardFrame({
+    chatId: input.chatId,
+    chatType: input.chatType,
+    card: input.card
+  });
+  try {
+    const err = target.sendCmd(frame.cmd, frame.body);
+    if (err)
+      return { ok: false, error: err.message };
+    return { ok: true, channel: "ws" };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var wecomRespondTool = {
+  name: "wecom_respond",
+  description: "Reply to the WeCom (企业微信) user. Primary path is the official wecom-cli " + "(message aibot send, markdown); WS long-connection frame is used as fallback. " + "This is the ONLY outbound channel for WeCom messages.",
+  parameters: z.object({
+    content: z.string().describe("Reply content (markdown supported)"),
+    chat_id: z.string().optional().describe("Target chat id (single chat = peer userid, group = chatid). " + "Defaults to the current event's chatId/senderId."),
+    req_id: z.string().optional().describe("Original message frame req_id (optional; used for WS fallback only). " + "Defaults to the current event metadata.reqId.")
+  }),
+  metadata: {
+    category: "messaging",
+    tags: ["wecom", "reply", "im"],
+    version: "2.0.0",
+    channelOnly: true
+  },
+  execute: async (args, _ctx) => {
+    const { content } = args;
+    let sourceId;
+    let eventChatId;
+    let eventReqId;
+    try {
+      const ctx = getEnvContextOrEmpty();
+      sourceId = typeof ctx.sourceId === "string" ? ctx.sourceId : undefined;
+      const meta = ctx.envEvent?.metadata;
+      const cid = meta?.chatId;
+      if (typeof cid === "string" && cid.length > 0)
+        eventChatId = cid;
+      const rid = meta?.reqId;
+      if (typeof rid === "string" && rid.length > 0)
+        eventReqId = rid;
+      if (!eventChatId) {
+        const rcChatId = ctx.replyChannel?.chatId;
+        if (typeof rcChatId === "string" && rcChatId.length > 0) {
+          eventChatId = rcChatId;
+        }
+      }
+      const rc = meta?.replyChannel;
+      if (!eventChatId && typeof rc?.chatId === "string" && rc.chatId) {
+        eventChatId = rc.chatId;
+      }
+      const rcParamsList = [
+        rc?.params,
+        ctx.replyChannel?.params
+      ];
+      for (const rcParams of rcParamsList) {
+        if (!rcParams)
+          continue;
+        if (!eventReqId) {
+          const prid = rcParams.reqId;
+          if (typeof prid === "string" && prid.length > 0)
+            eventReqId = prid;
+        }
+        if (!sourceId) {
+          const psid = rcParams.sourceId;
+          if (typeof psid === "string" && psid.length > 0)
+            sourceId = psid;
+        }
+      }
+      if (!sourceId && typeof ctx?.sourceId === "string" && ctx.sourceId) {
+        sourceId = ctx.sourceId;
+      }
+    } catch {}
+    const chatId = args.chat_id?.trim() || eventChatId;
+    const reqId = args.req_id?.trim() || eventReqId;
+    if (!chatId) {
+      return {
+        success: false,
+        output: "",
+        error: "wecom_respond: cannot resolve chat_id (no explicit chat_id and no EnvContext event chatId)."
+      };
+    }
+    if (!sourceId) {
+      sourceId = "unknown";
+    }
+    const startedAt = Date.now();
+    const result = await sendWecomReply({
+      sourceId,
+      rawChatId: chatId,
+      reqId,
+      content
+    });
+    if (!result.ok) {
+      return {
+        success: false,
+        output: "",
+        error: `wecom_respond: send failed: ${result.error ?? "unknown"}`
+      };
+    }
+    markWecomReplySent();
+    return {
+      success: true,
+      output: `Reply sent to WeCom via ${result.channel} ` + `(chat_id=${chatId}, ${content.length} chars)`,
+      metadata: {
+        execution_time_ms: Date.now() - startedAt,
+        channel: result.channel,
+        chat_id: chatId
+      }
+    };
+  }
+};
+var REPLY_SENT_KEY = "__wecomReplySent";
+function replySentBag(explicit) {
+  if (explicit)
+    return explicit;
+  try {
+    const ctx = getEnvContextOrEmpty();
+    return ctx.agentContext ??= {};
+  } catch {
+    return {};
+  }
+}
+function markWecomReplySent(explicitBag) {
+  replySentBag(explicitBag)[REPLY_SENT_KEY] = true;
+}
+function wasWecomReplySent(explicitBag) {
+  return replySentBag(explicitBag)[REPLY_SENT_KEY] === true;
+}
+function __resetWecomReplySentForTest(explicitBag) {
+  delete replySentBag(explicitBag)[REPLY_SENT_KEY];
+}
+var WECOM_EVENT_TYPE = "event-source.event.wecom-cli";
+async function autoReplyWecomTurn(envEvent, finalText) {
+  const evt = envEvent;
+  if (evt?.type !== WECOM_EVENT_TYPE) {
+    return { skipped: true, reason: "not a wecom event" };
+  }
+  const text = (finalText ?? "").trim();
+  if (!text)
+    return { skipped: true, reason: "empty final text" };
+  if (wasWecomReplySent()) {
+    return { skipped: true, reason: "already replied via tool" };
+  }
+  const meta = evt.metadata ?? {};
+  const chatId = typeof meta.chatId === "string" && meta.chatId || typeof meta.senderId === "string" && meta.senderId || "";
+  const sourceId = typeof meta.sourceId === "string" && meta.sourceId || "unknown";
+  const reqId = typeof meta.reqId === "string" ? meta.reqId : undefined;
+  if (!chatId) {
+    return { skipped: true, reason: "no chatId in event metadata" };
+  }
+  const r = await sendWecomReply({
+    sourceId,
+    rawChatId: chatId,
+    reqId,
+    content: text
+  });
+  return { skipped: false, ok: r.ok, channel: r.channel, error: r.error };
+}
+
+export { sendWecomCliMarkdown, registerWecomRespondTarget, unregisterWecomRespondTarget, getWecomRespondTarget, __resetWecomRespondRegistryForTest, sendWecomReply, sendWecomTemplateCard, wecomRespondTool, markWecomReplySent, wasWecomReplySent, __resetWecomReplySentForTest, autoReplyWecomTurn };

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

@@ -1,9 +1,9 @@
 import {
   init_hook
-} from "./roy-agent-core-ax9e9szb.js";
+} from "./roy-agent-core-smf94h73.js";
 import {
   globalHookManager
-} from "./roy-agent-core-cpcd24n2.js";
+} from "./roy-agent-core-yet36q5k.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -9,13 +9,16 @@ import {
   getCurrentProcessRegistry,
   killProcessTree
 } from "./roy-agent-core-fttgm52a.js";
+import {
+  wecomRespondTool
+} from "./roy-agent-core-h1e1fm9b.js";
 import {
   init_decorator,
   init_trace_filters,
   toolExecResultFilter,
   toolInvokeParamFilter,
   wrapFunction
-} from "./roy-agent-core-qq96p0tj.js";
+} from "./roy-agent-core-5s2t8z00.js";
 import {
   createLogger,
   exports_tracer_provider,
@@ -940,6 +943,7 @@ function getAllBuiltInTools() {
     editFileTool,
     grepTool,
     understandImageTool,
+    wecomRespondTool,
     queryBackgroundProcessTool,
     compactSessionTool
   ];

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

@@ -1,10 +1,10 @@
 import {
   createHook,
   init_hook
-} from "./roy-agent-core-ax9e9szb.js";
+} from "./roy-agent-core-smf94h73.js";
 import {
   HookManager
-} from "./roy-agent-core-cpcd24n2.js";
+} from "./roy-agent-core-yet36q5k.js";
 
 // src/env/component.ts
 init_hook();

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

@@ -3,11 +3,11 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pgvcf91v.js";
+} from "./roy-agent-core-m39v7qpx.js";
 import {
   init_decorator,
   init_trace_filters
-} from "./roy-agent-core-qq96p0tj.js";
+} from "./roy-agent-core-5s2t8z00.js";
 import {
   createLogger,
   getTracerProvider,

package/dist/shared/@ai-setting/{roy-agent-core-83bewqx8.js → roy-agent-core-mvh0td7p.js}

@@ -1,7 +1,7 @@
 import {
   TagRepository
-} from "./roy-agent-core-mcy5apay.js";
-import"./roy-agent-core-qq96p0tj.js";
+} from "./roy-agent-core-vf9sp6s3.js";
+import"./roy-agent-core-5s2t8z00.js";
 import"./roy-agent-core-7f7t9wwp.js";
 import"./roy-agent-core-85xyctnb.js";
 import"./roy-agent-core-fs0mn2jk.js";

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

@@ -1,6 +1,10 @@
 import {
   TempFileManager
 } from "./roy-agent-core-jvv2h3d6.js";
+import {
+  ToolValidator,
+  setToolReasonConfigComponent
+} from "./roy-agent-core-wxrkcb17.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -11,23 +15,23 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pgvcf91v.js";
+} from "./roy-agent-core-m39v7qpx.js";
 import {
   ToolHookPoints,
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-cpcd24n2.js";
+} from "./roy-agent-core-yet36q5k.js";
 import {
   getCurrentTaskId,
   init_env_context
-} from "./roy-agent-core-7cbpmk4q.js";
+} from "./roy-agent-core-p31ftgq9.js";
 import {
   TracedAs,
   init_decorator,
   init_trace_filters,
   toolExecResultFilter,
   toolInvokeParamFilter
-} from "./roy-agent-core-qq96p0tj.js";
+} from "./roy-agent-core-5s2t8z00.js";
 import {
   createLogger,
   init_logger
@@ -131,36 +135,6 @@ class ToolRegistry {
   }
 }
 
-// src/env/tool/validator.ts
-import { ZodError } from "zod";
-
-class ToolValidator {
-  async validate(tool, args) {
-    try {
-      const parsed = await tool.parameters.parseAsync(args);
-      return {
-        success: true,
-        data: parsed
-      };
-    } catch (error) {
-      if (error instanceof ZodError) {
-        const errorMessage = tool.formatValidationError ? tool.formatValidationError(error) : this.formatError(error);
-        return {
-          success: false,
-          error: `Invalid arguments for tool '${tool.name}': ${errorMessage}`
-        };
-      }
-      return {
-        success: false,
-        error: `Validation error: ${error}`
-      };
-    }
-  }
-  formatError(error) {
-    return error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
-  }
-}
-
 // src/env/constants.ts
 var TOOL_UNAVAILABLE_ERROR_RE = /^Tool (?:not found|disabled):/;
 function isToolUnavailableError(message) {
@@ -183,7 +157,8 @@ var TOOL_DEFAULTS = {
   "tool.sandbox.type": "native",
   "tool.execution.timeout": 30000,
   "tool.execution.maxConcurrency": 5,
-  "tool.execution.maxOutputSize": 5120
+  "tool.execution.maxOutputSize": 5120,
+  "tool.reason.required": true
 };
 var TOOL_CONFIG_REGISTRATION = {
   name: "tool",
@@ -198,7 +173,8 @@ var TOOL_CONFIG_REGISTRATION = {
     { key: "tool.sandbox.type", sources: ["env", "file"] },
     { key: "tool.execution.timeout", sources: ["env", "file"] },
     { key: "tool.execution.maxConcurrency", sources: ["env", "file"] },
-    { key: "tool.execution.maxOutputSize", sources: ["env", "file"] }
+    { key: "tool.execution.maxOutputSize", sources: ["env", "file"] },
+    { key: "tool.reason.required", sources: ["env", "file"] }
   ]
 };
 
@@ -307,6 +283,7 @@ class ToolComponent extends BaseComponent {
     }
     this.configComponent = options.configComponent;
     setToolConfigComponent(options.configComponent);
+    setToolReasonConfigComponent(options.configComponent);
     await this.registerConfig(options);
     if (this.config?.builtInTools?.enabled !== false) {
       await this.loadBuiltInTools();
@@ -338,7 +315,8 @@ class ToolComponent extends BaseComponent {
       "tool.sandbox.type",
       "tool.sandbox.defaultConfig",
       "tool.execution.timeout",
-      "tool.execution.maxConcurrency"
+      "tool.execution.maxConcurrency",
+      "tool.reason.required"
     ];
     for (const key of toolKeys) {
       const envKey = toEnvKey(key, prefix);
@@ -417,6 +395,7 @@ class ToolComponent extends BaseComponent {
   async onStop() {
     this.configWatcher?.();
     this.configWatcher = undefined;
+    setToolReasonConfigComponent(null);
     this.setStatus("stopped");
   }
   register(tool, source = "dynamic") {
@@ -614,4 +593,4 @@ var ToolComponentConfigSchema = z.object({
   }).default({})
 });
 
-export { ToolRegistry, ToolValidator, isToolUnavailableError, setToolConfigComponent, getMaxOutputSize, truncateOutputInline, ToolComponent };
+export { ToolRegistry, isToolUnavailableError, setToolConfigComponent, getMaxOutputSize, truncateOutputInline, ToolComponent };

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

@@ -1,7 +1,7 @@
 import {
   exports_node_registry_helper,
   init_node_registry_helper
-} from "./roy-agent-core-es203w7p.js";
+} from "./roy-agent-core-wqs6yypq.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -13,18 +13,18 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-mww0mnd9.js";
+} from "./roy-agent-core-azyz78ky.js";
 import {
   WorkflowService
-} from "./roy-agent-core-12n08pg5.js";
+} from "./roy-agent-core-e69qxdyy.js";
 import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-6rh8k6ba.js";
+} from "./roy-agent-core-6gj1hc5z.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pgvcf91v.js";
+} from "./roy-agent-core-m39v7qpx.js";
 import {
   createLogger,
   init_logger
@@ -104,7 +104,7 @@ class WorkflowComponent extends BaseComponent {
       return;
     try {
       const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
-      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-xcp8vwax.js");
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-fepm835e.js");
       this.nodeRegistry = new NodeRegistry;
       registerDecoratorNodeType2(this.nodeRegistry);
       this.decoratorsRegistered = true;
@@ -134,14 +134,14 @@ class WorkflowComponent extends BaseComponent {
   }
   async runWorkflow(definition, input, options) {
     const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
-    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-xcp8vwax.js");
+    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-fepm835e.js");
     const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
     const skillComponent = this._workflowEnv?.getComponent("skill");
     let agentRunner = this.agentRunner;
     if (!agentRunner && this._workflowEnv) {
       const agentComponent = this._workflowEnv.getComponent("agent");
       if (agentComponent) {
-        const { AgentComponentAdapter } = await import("./roy-agent-core-3fh1f7s7.js");
+        const { AgentComponentAdapter } = await import("./roy-agent-core-yfpnkc4z.js");
         agentRunner = new AgentComponentAdapter(agentComponent, {}, this.sessionComponent);
       }
     }
@@ -163,7 +163,7 @@ class WorkflowComponent extends BaseComponent {
     if (this.workflowService) {
       this.workflowService = null;
       try {
-        const { closeDatabase } = await import("./roy-agent-core-dc9zq75z.js");
+        const { closeDatabase } = await import("./roy-agent-core-0crmsc12.js");
         closeDatabase();
         componentLogger.info("[WorkflowComponent] SQLite database closed");
       } catch (error) {
@@ -241,9 +241,9 @@ class WorkflowComponent extends BaseComponent {
   }
   async initSqliteService() {
     try {
-      const { getDatabase, initializeTables } = await import("./roy-agent-core-dc9zq75z.js");
-      const { WorkflowRepository } = await import("./roy-agent-core-xvt7kf7p.js");
-      const { TagRepository } = await import("./roy-agent-core-83bewqx8.js");
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-0crmsc12.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-w9ryeg2p.js");
+      const { TagRepository } = await import("./roy-agent-core-mvh0td7p.js");
       const db = getDatabase();
       initializeTables();
       const workflowRepository = new WorkflowRepository(db);
@@ -309,7 +309,7 @@ class WorkflowComponent extends BaseComponent {
     this.workflowService = null;
     this.nodeRegistry = null;
     try {
-      const { closeDatabase } = await import("./roy-agent-core-dc9zq75z.js");
+      const { closeDatabase } = await import("./roy-agent-core-0crmsc12.js");
       closeDatabase();
     } catch {}
     this._status = "stopped";

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

@@ -1,6 +1,6 @@
 import {
   builtInPrompts
-} from "./roy-agent-core-9vxh6f8h.js";
+} from "./roy-agent-core-y7fqtzk2.js";
 import {
   getXDGPath
 } from "./roy-agent-core-qxnbvgwe.js";
@@ -10,14 +10,14 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-pgvcf91v.js";
+} from "./roy-agent-core-m39v7qpx.js";
 import {
   createHook
-} from "./roy-agent-core-ax9e9szb.js";
+} from "./roy-agent-core-smf94h73.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-cpcd24n2.js";
+} from "./roy-agent-core-yet36q5k.js";
 import {
   createLogger,
   init_logger