@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/add/sync.js

@@ -0,0 +1,139 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobAdd } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const AddSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `⛔ 重要：jobId 必须从 OpenClaw cron 工具返回值中提取，格式：{"success": true, "jobId": "123456"}
+
+常见错误：
+- 把 cron 表达式（如 "31 12 11 31 3 *"）当作 jobId
+- 把 name 当作 jobId
+- 编造 jobId
+
+正确做法：
+1. 调用 openclaw-workclaw-cron-add-params
+2. 用返回的 cronParams 调用 cron 工具
+3. 从返回值提取 jobId（如 "7382945612345"）
+4. 用提取到的 jobId 调用此工具`
+    },
+    name: {
+      type: "string",
+      description: "任务名称，与 add-params 中传入的 name 一致"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息，与 add-params 中传入的 message 一致"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-add-sync",
+    label: "智小途同步创建提醒",
+    description: `【后端同步步骤】将创建定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-add-params 执行后调用此工具完成同步。
+
+⚠️ jobId 必须是 cron 工具返回值 {"success": true, "jobId": "xxx"} 中的 jobId 字段！`,
+    parameters: AddSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-同步创建] 开始同步 jobId=${p.jobId} name=${p.name}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-同步创建] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const jobIdTrimmed = p.jobId.trim();
+      const parts = jobIdTrimmed.split(/\s+/);
+      const isCronExpression = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes("*");
+      if (isCronExpression) {
+        api.logger.error(`[智小途-同步创建] jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`);
+        return json({
+          error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`
+        });
+      }
+      if (!p.name) {
+        api.logger.warn("[智小途-同步创建] 缺少 name 参数");
+        return json({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        api.logger.warn("[智小途-同步创建] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-同步创建] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          api.logger.info(`[智小途-同步创建] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobAdd(api, accountId, {
+            jobId: p.jobId,
+            name: p.name,
+            kind: p.kind,
+            expr: p.expr,
+            message: p.message,
+            messageId: channelAgentId
+          });
+          if (result.success) {
+            api.logger.info(`[智小途-同步创建] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已创建并同步到后端",
+              data: {
+                jobId: p.jobId,
+                name: p.name,
+                message: p.message,
+                backendSynced: true
+              }
+            });
+          } else {
+            api.logger.error(`[智小途-同步创建] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId, name: p.name }
+            });
+          }
+        } catch (error) {
+          api.logger.error(`[智小途-同步创建] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      } else {
+        api.logger.error(`[智小途-同步创建] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronAddSyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/disable/params.js

@@ -0,0 +1,61 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const DisableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-params",
+    label: "智小途生成禁用提醒参数",
+    description: `生成禁用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-disable-sync 同步到后端`,
+    parameters: DisableParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-生成禁用参数] 开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-生成禁用参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-生成禁用参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      api.logger.info(`[智小途-生成禁用参数] accountId=${accountId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "disable",
+        jobId: p.jobId
+      };
+      api.logger.info(`[智小途-生成禁用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `⏸️ 提醒已禁用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronDisableParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/disable/sync.js

@@ -0,0 +1,85 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobDisabled } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const DisableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-sync",
+    label: "智小途同步禁用提醒",
+    description: "将禁用定时任务同步到后端。在 cron 工具禁用任务后调用此工具同步后端。",
+    parameters: DisableSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-同步禁用] 开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-同步禁用] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-同步禁用] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          api.logger.info(`[智小途-同步禁用] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobDisabled(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            api.logger.info(`[智小途-同步禁用] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已禁用并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            api.logger.error(`[智小途-同步禁用] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          api.logger.error(`[智小途-同步禁用] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        api.logger.error(`[智小途-同步禁用] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronDisableSyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/enable/params.js

@@ -0,0 +1,61 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const EnableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronEnableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-params",
+    label: "智小途生成启用提醒参数",
+    description: `生成启用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-enable-sync 同步到后端`,
+    parameters: EnableParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-生成启用参数] 开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-生成启用参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-生成启用参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      api.logger.info(`[智小途-生成启用参数] accountId=${accountId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "enable",
+        jobId: p.jobId
+      };
+      api.logger.info(`[智小途-生成启用参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `✅ 提醒已启用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronEnableParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/enable/sync.js

@@ -0,0 +1,85 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobEnabled } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const EnableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronEnableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-sync",
+    label: "智小途同步启用提醒",
+    description: "将启用定时任务同步到后端。在 cron 工具启用任务后调用此工具同步后端。",
+    parameters: EnableSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-同步启用] 开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-同步启用] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-同步启用] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          api.logger.info(`[智小途-同步启用] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobEnabled(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            api.logger.info(`[智小途-同步启用] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已启用并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            api.logger.error(`[智小途-同步启用] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          api.logger.error(`[智小途-同步启用] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        api.logger.error(`[智小途-同步启用] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronEnableSyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/notify/sync.js

@@ -0,0 +1,102 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobMessage } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const NotifySchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: "OpenClaw 任务 ID（从上下文获取）"
+    },
+    message: {
+      type: "string",
+      description: "要发送的提醒内容"
+    }
+  },
+  required: ["jobId", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronNotifySyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-notify-sync",
+    label: "智小途定时任务触发通知",
+    description: `【系统最高优先级核心指令】当定时器时间到达时，必须立即调用此工具通知后端。`,
+    parameters: NotifySchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-定时触发] 开始处理 jobId=${p.jobId} message=${p.message}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-定时触发] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      if (!p.message) {
+        api.logger.warn("[智小途-定时触发] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-定时触发] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        const channelAgentId = String(accountConfig.config.agentId);
+        api.logger.info(`[智小途-定时触发] accountId=${accountId} channelAgentId=${channelAgentId}`);
+        try {
+          const result = await callCronJobMessage(api, accountId, {
+            jobId: p.jobId,
+            message: p.message,
+            agentId: channelAgentId
+          });
+          if (result.success) {
+            api.logger.info(`[智小途-定时触发] 通知后端成功`);
+            return json({
+              code: 0,
+              message: "定时任务触发通知已发送",
+              data: {
+                jobId: p.jobId,
+                message: p.message,
+                backendNotified: true
+              }
+            });
+          } else {
+            api.logger.error(`[智小途-定时触发] 通知后端失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "通知后端失败",
+              data: {
+                jobId: p.jobId,
+                message: p.message
+              }
+            });
+          }
+        } catch (error) {
+          api.logger.error(`[智小途-定时触发] 通知后端异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message || "通知后端异常",
+            data: {
+              jobId: p.jobId,
+              message: p.message
+            }
+          });
+        }
+      } else {
+        api.logger.error(`[智小途-定时触发] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronNotifySyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/remove/params.js

@@ -0,0 +1,67 @@
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const RemoveParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronRemoveParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-params",
+    label: "智小途生成删除提醒参数",
+    description: `生成删除提醒的 CLI 命令。
+**必须**严格按照以下格式执行：
+openclaw cron remove <jobId>
+
+示例：openclaw cron remove 123456
+`,
+    parameters: RemoveParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-生成删除参数] 开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-生成删除参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const agentId = ctx?.agentId;
+      if (!accountId) {
+        api.logger.warn("[智小途-生成删除参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      if (!agentId) {
+        api.logger.warn("[智小途-生成删除参数] 无法获取智能体 ID");
+        return json({ error: "无法获取智能体 ID（agentId），请确保已配置智能体" });
+      }
+      api.logger.info(`[智小途-生成删除参数] accountId=${accountId} agentId=${agentId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "remove",
+        jobId: p.jobId
+      };
+      api.logger.info(`[智小途-生成删除参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          agentId,
+          jobId: p.jobId
+        },
+        summary: `🗑️ 提醒已删除: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronRemoveParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/remove/sync.js

@@ -0,0 +1,85 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobRemove } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const RemoveSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronRemoveSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-sync",
+    label: "智小途同步删除提醒",
+    description: "【后端同步步骤】将删除定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-remove-params 执行后调用此工具完成同步。",
+    parameters: RemoveSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-同步删除] 开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-同步删除] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        api.logger.warn("[智小途-同步删除] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          api.logger.info(`[智小途-同步删除] accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobRemove(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            api.logger.info(`[智小途-同步删除] 后端同步成功 jobId=${p.jobId}`);
+            return json({
+              code: 0,
+              message: "定时任务已删除并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            api.logger.error(`[智小途-同步删除] 后端同步失败 ${result.error}`);
+            return json({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          api.logger.error(`[智小途-同步删除] 后端同步异常 ${error.message}`);
+          return json({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        api.logger.error(`[智小途-同步删除] 无法获取渠道配置，accountId=${accountId}`);
+        return json({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronRemoveSyncTool
+};