@ai-setting/roy-agent-core 1.5.80 → 1.5.81

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

@@ -0,0 +1,428 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-shme7set.js";
+
+// src/env/workflow/tools/ask-user-tool.ts
+init_workflow_hil();
+import { z } from "zod";
+var AskUserInputSchema = z.object({
+  query: z.string().describe("The question or request to ask the user"),
+  options: z.array(z.string()).optional().describe("Optional choices for the user"),
+  required_confirm: z.boolean().optional().describe("If true, user must explicitly confirm")
+});
+var askUserTool = {
+  name: "ask_user",
+  description: "Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.",
+  parameters: AskUserInputSchema,
+  async execute(args, context) {
+    const runId = context.metadata?.runId || "unknown";
+    const sessionId = context.metadata?.sessionId || `workflow_${runId}`;
+    const nodeId = context.metadata?.nodeId || "unknown";
+    let fullQuery = args.query;
+    if (args.options && args.options.length > 0) {
+      fullQuery = `${args.query} (选项: ${args.options.join(", ")})`;
+    }
+    throw new AskUserError(runId, sessionId, nodeId, "agent", fullQuery);
+  },
+  metadata: {
+    category: "workflow",
+    tags: ["human-in-loop", "user-input"],
+    version: "1.0.0"
+  }
+};
+var askUserToolInstance = askUserTool;
+
+// src/env/workflow/tools/workflow-get-tool.ts
+init_logger();
+import { z as z2 } from "zod";
+var logger = createLogger("workflow-get-tool");
+var WorkflowGetInputSchema = z2.object({
+  name: z2.string().optional().describe("Workflow name to get definition details"),
+  run_id: z2.string().optional().describe("Run/session ID to get run status")
+});
+function createWorkflowGetTool(workflowService) {
+  return {
+    name: "workflow_get",
+    description: "Get workflow definition details by name, or run status by run_id. Returns workflow name, version, description, inputs schema, and node list.",
+    parameters: WorkflowGetInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowGetInputSchema.parse(args);
+      try {
+        if (params.run_id) {
+          const session = await workflowService.getSession(params.run_id);
+          if (!session) {
+            return {
+              success: false,
+              output: "",
+              error: `Run not found: ${params.run_id}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          let messages = [];
+          try {
+            messages = await workflowService.getSessionMessages(params.run_id);
+          } catch {}
+          return {
+            success: true,
+            output: JSON.stringify({
+              run_id: session.id,
+              status: session.metadata?.status,
+              workflow_name: session.metadata?.workflowName,
+              workflow_version: session.metadata?.workflowVersion,
+              input: session.metadata?.input,
+              created_at: session.createdAt,
+              updated_at: session.updatedAt,
+              message_count: messages.length
+            }, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        if (params.name) {
+          const workflow = workflowService.getWorkflowByName(params.name);
+          if (!workflow) {
+            return {
+              success: false,
+              output: "",
+              error: `Workflow not found: ${params.name}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          return {
+            success: true,
+            output: JSON.stringify({
+              name: workflow.name,
+              version: workflow.version,
+              description: workflow.description,
+              inputs: workflow.definition.inputs,
+              definition: workflow.definition,
+              config: workflow.definition.config,
+              tags: workflow.tags,
+              created_at: workflow.createdAt,
+              updated_at: workflow.updatedAt
+            }, null, 2),
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: false,
+          output: "",
+          error: "Either 'name' or 'run_id' must be provided",
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger.error("Failed to get workflow info", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-list-tool.ts
+init_logger();
+import { z as z3 } from "zod";
+var logger2 = createLogger("workflow-list-tool");
+var WorkflowListInputSchema = z3.object({
+  tag: z3.string().optional().describe("Filter by tag"),
+  search: z3.string().optional().describe("Search workflows by keyword"),
+  limit: z3.number().positive().optional().describe("Maximum number of results to return"),
+  offset: z3.number().min(0).optional().describe("Offset for pagination")
+});
+function createWorkflowListTool(workflowService) {
+  return {
+    name: "workflow_list",
+    description: "List all registered workflows with optional filtering by tag or keyword search. Returns workflow name, version, description, and tags.",
+    parameters: WorkflowListInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowListInputSchema.parse(args);
+      try {
+        const options = {};
+        if (params.tag !== undefined)
+          options.tag = params.tag;
+        if (params.search !== undefined)
+          options.search = params.search;
+        if (params.limit !== undefined)
+          options.limit = params.limit;
+        if (params.offset !== undefined)
+          options.offset = params.offset;
+        const workflows = workflowService.listWorkflows(options);
+        return {
+          success: true,
+          output: JSON.stringify({
+            workflows: workflows.map((w) => ({
+              name: w.name,
+              version: w.version,
+              description: w.description,
+              tags: w.tags,
+              created_at: w.createdAt
+            })),
+            total: workflows.length,
+            count: workflows.length,
+            limit: params.limit,
+            offset: params.offset
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger2.error("Failed to list workflows", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/run-workflow.ts
+init_logger();
+import { z as z4 } from "zod";
+var logger3 = createLogger("run-workflow-tool");
+var RunWorkflowInputSchema = z4.object({
+  workflow_name: z4.string().describe("Name of the workflow to run"),
+  input: z4.record(z4.any()).optional().describe("Input to pass to the workflow"),
+  sync: z4.boolean().default(true).describe("Wait for completion (default: true)"),
+  timeout: z4.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
+});
+function createRunWorkflowTool(workflowService) {
+  return {
+    name: "workflow_run",
+    description: "Run a workflow by name with optional input. Returns run_id, status, output, error, and duration_ms. Default timeout: 30 minutes.",
+    parameters: RunWorkflowInputSchema,
+    sandbox: {
+      enabled: false
+    },
+    permission: {
+      level: "safe"
+    },
+    metadata: {
+      category: "workflow",
+      tags: ["workflow", "execute", "run"],
+      version: "1.0.0",
+      experimental: false
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { workflow_name, input, sync = true, timeout = 1800000 } = args;
+      logger3.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
+      let timeoutHandle;
+      let durationMs;
+      try {
+        let result;
+        if (timeout) {
+          result = await Promise.race([
+            workflowService.runWorkflow(workflow_name, input, { sync }),
+            new Promise((_, reject) => {
+              timeoutHandle = setTimeout(() => {
+                reject(new Error("Workflow execution timed out"));
+              }, timeout);
+            })
+          ]);
+        } else {
+          result = await workflowService.runWorkflow(workflow_name, input, { sync });
+        }
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        durationMs = Date.now() - startTime;
+        if (sync) {
+          return {
+            success: result.status === "completed",
+            output: {
+              run_id: result.runId,
+              status: result.status,
+              output: result.output,
+              error: result.error,
+              duration_ms: result.durationMs || durationMs
+            },
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        } else {
+          return {
+            success: true,
+            output: {
+              run_id: result.runId,
+              status: result.status,
+              duration_ms: durationMs
+            },
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+      } catch (error) {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        durationMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("Workflow not found")) {
+          return {
+            success: false,
+            output: "",
+            error: `Workflow not found: ${workflow_name}`,
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+        if (errorMessage.includes("abort") || errorMessage.includes("timed out")) {
+          return {
+            success: false,
+            output: "",
+            error: `Workflow execution timed out or was aborted: ${workflow_name}`,
+            metadata: {
+              execution_time_ms: durationMs
+            }
+          };
+        }
+        if (logger3?.error) {
+          logger3.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+        }
+        return {
+          success: false,
+          output: "",
+          error: `Failed to run workflow ${workflow_name}: ${errorMessage}`,
+          metadata: {
+            execution_time_ms: durationMs
+          }
+        };
+      }
+    }
+  };
+}
+var _runWorkflowTool = null;
+var _workflowService = null;
+function initRunWorkflowTool(workflowService) {
+  _workflowService = workflowService;
+  _runWorkflowTool = createRunWorkflowTool(workflowService);
+}
+function getRunWorkflowTool() {
+  if (!_runWorkflowTool || !_workflowService) {
+    throw new Error("workflow_run tool not initialized. Call initRunWorkflowTool(workflowService) first.");
+  }
+  return _runWorkflowTool;
+}
+function resetRunWorkflowTool() {
+  _runWorkflowTool = null;
+  _workflowService = null;
+}
+function createLegacyRunWorkflowTool(workflowService) {
+  const tool = createRunWorkflowTool(workflowService);
+  return {
+    ...tool,
+    name: "run-workflow"
+  };
+}
+
+// src/env/workflow/tools/workflow-run-status-tool.ts
+init_logger();
+import { z as z5 } from "zod";
+var logger4 = createLogger("workflow-run-status-tool");
+var WorkflowRunStatusInputSchema = z5.object({
+  run_id: z5.string().describe("Run/session ID to query status")
+});
+function createWorkflowRunStatusTool(workflowService) {
+  return {
+    name: "workflow_run_status",
+    description: "Query the status of a workflow run by run_id. Returns run_id, status, output, error, and progress information.",
+    parameters: WorkflowRunStatusInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowRunStatusInputSchema.parse(args);
+      try {
+        const session = await workflowService.getSession(params.run_id);
+        if (!session) {
+          return {
+            success: false,
+            output: "",
+            error: `Run not found: ${params.run_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const metadata = session.metadata;
+        let messages = [];
+        try {
+          messages = await workflowService.getSessionMessages(params.run_id);
+        } catch {}
+        return {
+          success: true,
+          output: JSON.stringify({
+            run_id: session.id,
+            title: session.title,
+            status: metadata?.status || "unknown",
+            workflow_name: metadata?.workflowName,
+            workflow_version: metadata?.workflowVersion,
+            input: metadata?.input,
+            created_at: session.createdAt,
+            updated_at: session.updatedAt,
+            message_count: messages.length
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger4.error("Failed to get run status", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-run-stop-tool.ts
+init_logger();
+import { z as z6 } from "zod";
+var logger5 = createLogger("workflow-run-stop-tool");
+var WorkflowRunStopInputSchema = z6.object({
+  run_id: z6.string().describe("Run/session ID to stop"),
+  reason: z6.string().optional().describe("Optional reason for stopping the workflow")
+});
+function createWorkflowRunStopTool(workflowService) {
+  return {
+    name: "workflow_run_stop",
+    description: "Stop a running workflow by run_id. Optionally provide a reason. Returns success status.",
+    parameters: WorkflowRunStopInputSchema,
+    execute: async (args, ctx) => {
+      const params = WorkflowRunStopInputSchema.parse(args);
+      try {
+        await workflowService.stopRun(params.run_id, params.reason);
+        return {
+          success: true,
+          output: JSON.stringify({
+            success: true,
+            run_id: params.run_id,
+            status: "stopped",
+            reason: params.reason || undefined
+          }, null, 2),
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger5.error("Failed to stop workflow run", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };

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

@@ -143,8 +143,12 @@ function createTaskTool(taskComponent) {
          then create the child task with that parent_task_id.
       
       **Example:**
-      - First: task_list(depth=0) → find root task #619 "roy-agent"
-      - Then: task_create(title="New feature", parent_task_id=619, ...)
+      - First: task_list(depth=0) → find an appropriate root task for your project
+        (e.g. one whose title matches your project name). Use the returned root task's
+        id as \`parent_task_id\` — do NOT hardcode a specific id; the root task id varies
+        across deployments and resets.
+      - Then: task_create(title="New feature", parent_task_id=<root_task_id>, ...)
+        where \`<root_task_id>\` is the id returned by task_list, NOT a hardcoded number.
     `,
     parameters: CreateTaskToolSchema,
     execute: async (args, ctx) => {

package/dist/shared/@ai-setting/{roy-agent-core-0tgnq4nz.js → roy-agent-core-f6p7wwpd.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_SUBAGENT_PROMPT
-} from "./roy-agent-core-zf62vkc4.js";
+} from "./roy-agent-core-mbre4fxg.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
@@ -211,6 +211,32 @@ var DelegateToolParameters = z.object({
   reason: z.string().describe("Brief reason for calling this tool (max 30 chars, e.g., 'Delegate refactor task')").optional(),
   similar_task_ids: z.array(z.number()).max(3).describe("Similar task IDs (max 3) to reference for improving task execution. Search for similar tasks before calling this tool.")
 });
+function buildEntryAgentPrompt(options) {
+  const { workflowName, originalPrompt, description } = options;
+  return `# Workflow 调度请求
+
+你被调用是因为上游 \`delegate_task\` 检测到 workflow 类型 subagent **${workflowName}**。
+请通过 \`workflow run\` 命令调度对应 workflow。
+
+## 调度目标
+
+- **Workflow 名称**: \`${workflowName}\`
+- **任务描述**: ${description}
+
+## 原始用户请求
+
+${originalPrompt}
+
+## 你的行动
+
+1. \`workflow get ${workflowName}\` 查 workflow 入参 schema
+2. 从"原始用户请求"提取符合 schema 的 input 字段
+3. \`workflow run ${workflowName} --input '<json>'\` 触发 workflow
+4. 返回结果
+
+不要做其他工作。只走 \`workflow run\` 路径。
+`;
+}
 var DEFAULT_TIMEOUT = 1800000;
 var PROGRESS_INTERVAL = 120000;
 
@@ -222,6 +248,21 @@ class BackgroundTaskManager {
   constructor(env) {
     this.env = env;
   }
+  static DEFAULT_WORKFLOW_ENTRY_AGENT = "workflow-agent";
+  resolveEntryAgent(subagentType) {
+    try {
+      const agentComponent = this.env?.getComponent?.("agent");
+      const registry = agentComponent?.getRegistry?.();
+      const agent = registry?.get?.(subagentType);
+      if (!agent || agent.type !== "workflow") {
+        return;
+      }
+      return agent.entryAgent ?? BackgroundTaskManager.DEFAULT_WORKFLOW_ENTRY_AGENT;
+    } catch (err) {
+      logger.warn(`[BackgroundTaskManager] resolveEntryAgent failed for ${subagentType}: ${err}`);
+      return;
+    }
+  }
   getSessionComponent() {
     return this.env?.getComponent?.("session");
   }
@@ -614,6 +655,9 @@ Use these as guidance to improve task execution efficiency.`;
     logger.info(`[BackgroundTaskManager] Disposed`);
   }
 }
+__legacyDecorateClassTS([
+  TracedAs("task.background.resolveEntryAgent", { recordParams: true, recordResult: true })
+], BackgroundTaskManager.prototype, "resolveEntryAgent", null);
 __legacyDecorateClassTS([
   TracedAs("task.background.createTask", { recordParams: false, recordResult: true, log: true })
 ], BackgroundTaskManager.prototype, "createTask", null);
@@ -716,20 +760,35 @@ No need to poll — just wait for the notification and use \`task_get\` with the
 async function handleBackgroundTask(backgroundTaskManager, parentSessionId, description, prompt, subagentType, timeout, similarTaskIds) {
   const startTime = Date.now();
   try {
+    let actualSubagentType = subagentType;
+    let actualPrompt = prompt;
+    let originalWorkflowName;
+    const entryAgent = backgroundTaskManager.resolveEntryAgent(subagentType);
+    if (entryAgent) {
+      originalWorkflowName = subagentType;
+      actualSubagentType = entryAgent;
+      actualPrompt = buildEntryAgentPrompt({
+        workflowName: originalWorkflowName,
+        originalPrompt: prompt,
+        description
+      });
+      logger.info(`[delegate_task] Routing workflow subagent '${subagentType}' → entry-agent '${entryAgent}'`);
+    }
     const { taskId: bgProcessId, subSessionId } = await backgroundTaskManager.createTask({
       parentSessionId,
       description,
-      prompt,
-      subagentType,
+      prompt: actualPrompt,
+      subagentType: actualSubagentType,
       timeout,
-      similarTaskIds
+      similarTaskIds,
+      originalWorkflowName
     });
     const output = [
       `✅ Background task accepted`,
       "",
       `\uD83D\uDCCB Process ID: ${bgProcessId}`,
       `\uD83D\uDCDD Description: ${description}`,
-      `\uD83E\uDD16 Sub-agent: ${subagentType}`,
+      `\uD83E\uDD16 Sub-agent: ${actualSubagentType}${originalWorkflowName ? ` (workflow: ${originalWorkflowName})` : ""}`,
       `⏱️ Timeout: ${(timeout || DEFAULT_TIMEOUT) / 1000}s`,
       "",
       `Use stop_task with task_id="${bgProcessId}" to cancel this task.`

package/dist/shared/@ai-setting/{roy-agent-core-99j4w3fx.js → roy-agent-core-gb9gbkc3.js}

@@ -105,6 +105,8 @@ var init_template_resolver = __esm(() => {
         return template;
       }
       let resolved = template;
+      resolved = resolved.replace(/\{\{\s+/g, "{{");
+      resolved = resolved.replace(/\s+\}\}/g, "}}");
       resolved = resolved.replace(/\{\{inputs\./g, "{{input.");
       resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
         const value = this.getNestedValue(this.input, path);

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

@@ -64,6 +64,19 @@ var init_tool_node = __esm(() => {
         } else {
           input = {};
         }
+        if (toolName === "bash" && typeof input.command === "string") {
+          const trimmed = input.command.replace(/\n+$/, "");
+          const echoMatch = trimmed.match(/^echo\s+"([\s\S]*)"\s*$/);
+          if (echoMatch) {
+            let inner = echoMatch[1];
+            inner = inner.replace(/\\/g, "\\\\");
+            inner = inner.replace(/"/g, "\\\"");
+            inner = inner.replace(/\$/g, "\\$");
+            inner = inner.replace(/\`/g, "\\`");
+            inner = inner.replace(/\n/g, "\\n");
+            input.command = 'echo "' + inner + '"';
+          }
+        }
         let output;
         try {
           const toolContext = {

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

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-n9tw52zb.js";
+} from "./roy-agent-core-w83v54mj.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";

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

@@ -26,6 +26,7 @@ var AgentConfigSchema = z.object({
   name: z.string(),
   type: z.enum(["primary", "sub", "workflow"]),
   workflow: z.string().optional(),
+  entryAgent: z.string().optional(),
   description: z.string().optional(),
   systemPromptRef: z.string().optional(),
   systemPrompt: z.string().optional(),
@@ -150,6 +151,32 @@ class AgentRegistry {
     }
     return agent.workflow;
   }
+  getEntryAgent(name) {
+    const agent = this.agents.get(name);
+    if (!agent || agent.type !== "workflow") {
+      return;
+    }
+    return agent.entryAgent;
+  }
+  registerWorkflowAgent() {
+    const name = "workflow-agent";
+    if (this.agents.has(name))
+      return;
+    const agent = {
+      name,
+      type: "primary",
+      description: "Workflow 调度中介 — 负责将请求转交给 workflow run 执行",
+      allowedTools: [
+        "workflow_get",
+        "workflow_list",
+        "workflow_run",
+        "workflow_run_status",
+        "workflow_run_stop"
+      ],
+      deniedTools: []
+    };
+    this.agents.set(name, agent);
+  }
   async load() {
     try {
       return await this.loadFromDirectory(this.configDir);
@@ -249,7 +276,8 @@ class AgentRegistry {
       ...agent.toolRetries !== undefined ? { toolRetries: agent.toolRetries } : {},
       ...agent.doomLoopThreshold !== undefined ? { doomLoopThreshold: agent.doomLoopThreshold } : {},
       ...agent.filterHistory !== undefined ? { filterHistory: agent.filterHistory } : {},
-      ...agent.workflow !== undefined ? { workflow: agent.workflow } : {}
+      ...agent.workflow !== undefined ? { workflow: agent.workflow } : {},
+      ...agent.entryAgent !== undefined ? { entryAgent: agent.entryAgent } : {}
     };
     return yaml.stringify(config).trimEnd() + `
 `;
@@ -308,6 +336,9 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("agent.registry.getWorkflowName", { recordParams: true, recordResult: true })
 ], AgentRegistry.prototype, "getWorkflowName", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.getEntryAgent", { recordParams: true, recordResult: true })
+], AgentRegistry.prototype, "getEntryAgent", null);
 __legacyDecorateClassTS([
   TracedAs("agent.registry.load", { recordParams: false, recordResult: true, log: true })
 ], AgentRegistry.prototype, "load", null);

package/dist/shared/@ai-setting/{roy-agent-core-11dnsfwp.js → roy-agent-core-p8jv13bm.js}

@@ -5,7 +5,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-0tgnq4nz.js";
+} from "./roy-agent-core-f6p7wwpd.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
@@ -20,7 +20,7 @@ import {
   listTasksTool,
   searchTasksTool,
   updateTaskTool
-} from "./roy-agent-core-7t0jen73.js";
+} from "./roy-agent-core-df3ng0pz.js";
 import {
   createOperationTool,
   deleteOperationTool,