@workclaw/openclaw-workclaw 1.0.25 → 1.0.27

package/dist/index.js

@@ -0,0 +1,2088 @@
+import { readFile, stat, mkdir, writeFile, unlink } from "node:fs/promises";
+import path from "node:path";
+import process$1 from "node:process";
+import { fileURLToPath } from "node:url";
+import { n as normalizeAccountId, g as getWorkclawLogger, a as getWorkclawRuntime, r as resolveWorkclawAccountWithCache, b as normalizeBaseUrl, c as getWorkclawAccessToken, d as doFetchJson, w as workclawPlugin, s as setWorkclawRuntime, e as deleteToolContext, f as getToolContext, h as getToolResultHint, i as sendMessageWorkclaw, j as setToolCallIdToRunIdMapping } from "./channel-DSvR6Irx.js";
+import { e as emptyChannelConfigSchema } from "./jiti-4i2h0FGP.js";
+import os from "node:os";
+import "node:fs";
+import "node:net";
+import "node:crypto";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+function error(message) {
+  return {
+    success: false,
+    error: { issues: [{
+      path: [],
+      message
+    }] }
+  };
+}
+function emptyPluginConfigSchema() {
+  return {
+    safeParse(value) {
+      if (value === void 0) return {
+        success: true,
+        data: void 0
+      };
+      if (!value || typeof value !== "object" || Array.isArray(value)) return error("expected config object");
+      if (Object.keys(value).length > 0) return error("config must be empty");
+      return {
+        success: true,
+        data: value
+      };
+    },
+    jsonSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    }
+  };
+}
+function defineChannelPluginEntry({ id, name, description, plugin, configSchema, setRuntime, registerCliMetadata, registerFull }) {
+  return {
+    id,
+    name,
+    description,
+    configSchema: typeof configSchema === "function" ? configSchema() : configSchema ?? emptyChannelConfigSchema(),
+    register(api) {
+      if (api.registrationMode === "cli-metadata") {
+        registerCliMetadata?.(api);
+        return;
+      }
+      setRuntime?.(api.runtime);
+      api.registerChannel({ plugin });
+      if (api.registrationMode !== "full") return;
+      registerCliMetadata?.(api);
+      registerFull?.(api);
+    },
+    channelPlugin: plugin,
+    ...setRuntime ? { setChannelRuntime: setRuntime } : {}
+  };
+}
+function sendJson$3(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+async function readRequestBody$2(req) {
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve());
+    req.on("error", (err) => reject(err));
+  });
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function loadRuntimeConfig(api) {
+  const runtimeConfig = api.runtime?.config;
+  if (runtimeConfig?.loadConfig) {
+    return runtimeConfig.loadConfig();
+  }
+  return api.config;
+}
+async function writeRuntimeConfig(api, config) {
+  const runtimeConfig = api.runtime?.config;
+  if (runtimeConfig?.writeConfigFile) {
+    await runtimeConfig.writeConfigFile(config);
+    return;
+  }
+  throw new Error("Config write not supported");
+}
+function getAccountMap(config) {
+  const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+  const openclawWorkclaw = channels["openclaw-workclaw"] && typeof channels["openclaw-workclaw"] === "object" ? channels["openclaw-workclaw"] : {};
+  const accounts = openclawWorkclaw.accounts && typeof openclawWorkclaw.accounts === "object" ? openclawWorkclaw.accounts : {};
+  return { ...accounts };
+}
+function withAccounts(config, accounts) {
+  const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+  const openclawWorkclaw = channels["openclaw-workclaw"] && typeof channels["openclaw-workclaw"] === "object" ? channels["openclaw-workclaw"] : {};
+  return {
+    ...config,
+    channels: {
+      ...channels,
+      "openclaw-workclaw": {
+        ...openclawWorkclaw,
+        accounts
+      }
+    }
+  };
+}
+function createAccountsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const idRaw = url.searchParams.get("id") ?? url.searchParams.get("accountId");
+    const accountId = idRaw ? normalizeAccountId(idRaw) : null;
+    if (method === "GET") {
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (accountId) {
+        const account = accounts[accountId];
+        if (!account) {
+          sendJson$3(res, 404, { ok: false, error: "Not Found" });
+          return;
+        }
+        sendJson$3(res, 200, { ok: true, accountId, config: account });
+        return;
+      }
+      const entries = Object.entries(accounts).map(([id, config]) => ({
+        accountId: id,
+        config
+      }));
+      sendJson$3(res, 200, { ok: true, accounts: entries });
+      return;
+    }
+    if (method === "POST" || method === "PUT") {
+      const raw = await readRequestBody$2(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson$3(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const inputId = input?.accountId ?? input?.id;
+      const normalizedId = inputId ? normalizeAccountId(String(inputId)) : "";
+      const patch = input?.config;
+      if (!normalizedId || !patch || typeof patch !== "object") {
+        sendJson$3(res, 400, { ok: false, error: "Missing accountId or config" });
+        return;
+      }
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (method === "POST" && accounts[normalizedId]) {
+        sendJson$3(res, 409, { ok: false, error: "Account already exists" });
+        return;
+      }
+      if (method === "PUT" && !accounts[normalizedId]) {
+        sendJson$3(res, 404, { ok: false, error: "Not Found" });
+        return;
+      }
+      const next = method === "PUT" ? { ...accounts[normalizedId], ...patch } : patch;
+      const updated = withAccounts(cfg, { ...accounts, [normalizedId]: next });
+      await writeRuntimeConfig(api, updated);
+      sendJson$3(res, 200, { ok: true, accountId: normalizedId });
+      return;
+    }
+    if (method === "DELETE") {
+      if (!accountId) {
+        sendJson$3(res, 400, { ok: false, error: "Missing accountId" });
+        return;
+      }
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (!accounts[accountId]) {
+        sendJson$3(res, 404, { ok: false, error: "Not Found" });
+        return;
+      }
+      const { [accountId]: _ignored, ...rest } = accounts;
+      const updated = withAccounts(cfg, rest);
+      await writeRuntimeConfig(api, updated);
+      sendJson$3(res, 200, { ok: true, accountId, deleted: true });
+      return;
+    }
+    sendJson$3(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+function resolveWorkspaceDir(api) {
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent = agents.find((agent) => agent?.default === true) ?? agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+  const workspaceRaw = typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim() || typeof api.config.agents?.defaults?.workspace === "string" && api.config.agents.defaults.workspace.trim();
+  getWorkclawLogger().info(`workspaceRaw: ${workspaceRaw}`);
+  if (workspaceRaw) {
+    return api.resolvePath(workspaceRaw);
+  }
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  const suffix = profile && profile.toLowerCase() !== "default" ? `workspace-${profile}` : "workspace";
+  return path.join(os.homedir(), ".openclaw", suffix);
+}
+function isDefaultWorkspace(api) {
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent = agents.find((agent) => agent?.default === true) ?? agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+  const workspaceRaw = typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim() || typeof api.config.agents?.defaults?.workspace === "string" && api.config.agents.defaults.workspace.trim();
+  if (workspaceRaw)
+    return false;
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  return !profile || profile.toLowerCase() === "default";
+}
+const promptNames = ["SOUL.md", "USER.md"];
+function normalizePromptName(raw) {
+  const name = String(raw ?? "").trim().toUpperCase();
+  if (name === "SOUL" || name === "SOUL.MD")
+    return "SOUL.md";
+  if (name === "USER" || name === "USER.MD")
+    return "USER.md";
+  return null;
+}
+function resolvePromptPath(api, name) {
+  return path.join(resolveWorkspaceDir(api), name);
+}
+function sendJson$2(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function createPromptsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const name = normalizePromptName(url.searchParams.get("name"));
+    if (method === "GET") {
+      if (name) {
+        const filePath = resolvePromptPath(api, name);
+        try {
+          const content = await readFile(filePath, "utf-8");
+          sendJson$2(res, 200, { ok: true, name, content });
+          return;
+        } catch (error2) {
+          sendJson$2(res, 404, { ok: false, error: "Not Found" });
+          return;
+        }
+      }
+      const entries = await Promise.all(
+        promptNames.map(async (promptName) => {
+          const filePath = resolvePromptPath(api, promptName);
+          try {
+            const info = await stat(filePath);
+            return { name: promptName, exists: true, bytes: info.size };
+          } catch {
+            return { name: promptName, exists: false, bytes: 0 };
+          }
+        })
+      );
+      sendJson$2(res, 200, { ok: true, entries });
+      return;
+    }
+    if (method === "PUT" || method === "POST") {
+      const raw = await readRequestBody$1(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson$2(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const targetName = normalizePromptName(input?.name);
+      const content = typeof input?.content === "string" ? input.content : null;
+      if (!targetName || content === null) {
+        sendJson$2(res, 400, { ok: false, error: "Missing name or content" });
+        return;
+      }
+      const workspaceDir = resolveWorkspaceDir(api);
+      await mkdir(workspaceDir, { recursive: true });
+      await writeFile(resolvePromptPath(api, targetName), content, { encoding: "utf-8" });
+      sendJson$2(res, 200, { ok: true, name: targetName });
+      return;
+    }
+    if (method === "DELETE") {
+      if (!name) {
+        sendJson$2(res, 400, { ok: false, error: "Missing name" });
+        return;
+      }
+      const filePath = resolvePromptPath(api, name);
+      try {
+        await unlink(filePath);
+        sendJson$2(res, 200, { ok: true, name, deleted: true });
+        return;
+      } catch {
+        sendJson$2(res, 200, { ok: true, name, deleted: false });
+        return;
+      }
+    }
+    sendJson$2(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+async function readRequestBody$1(req) {
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve());
+    req.on("error", (err) => reject(err));
+  });
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function sendJson$1(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+async function readRequestBody(req) {
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve());
+    req.on("error", (err) => reject(err));
+  });
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function buildSessionKey(accountId, userId) {
+  return `openclaw-workclaw:${accountId}:${userId}`;
+}
+function parseSessionKey(sessionKey) {
+  const parts = sessionKey.split(":");
+  if (parts.length !== 3 || parts[0] !== "openclaw-workclaw") {
+    return null;
+  }
+  return {
+    channel: parts[0],
+    accountId: parts[1],
+    userId: parts[2]
+  };
+}
+async function resetSession(sessionKey, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    runtime.system.enqueueSystemEvent("/new", {
+      sessionKey,
+      contextKey: null
+    });
+    log?.info?.(`[SessionAPI] Sent /new command to session: ${sessionKey}`);
+    return {
+      success: true,
+      message: `Session reset command sent to ${sessionKey}`
+    };
+  } catch (err) {
+    const errorMsg = `Failed to reset session: ${String(err)}`;
+    log?.error?.(`[SessionAPI] ${errorMsg}`);
+    return { success: false, message: errorMsg };
+  }
+}
+function getSessionStorePath(agentId, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const storePath = runtime.channel.session.resolveStorePath(void 0, {
+      agentId
+    });
+    return storePath;
+  } catch (err) {
+    log?.error?.(`[SessionAPI] Failed to resolve store path: ${String(err)}`);
+    return null;
+  }
+}
+async function getSessionLastUpdated(sessionKey, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const storePath = runtime.channel.session.resolveStorePath();
+    const updatedAt = runtime.channel.session.readSessionUpdatedAt({
+      storePath,
+      sessionKey
+    });
+    return updatedAt ?? null;
+  } catch (err) {
+    log?.error?.(`[SessionAPI] Failed to read session updated at: ${String(err)}`);
+    return null;
+  }
+}
+function createSessionApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const fullPath = url.pathname.replace(/\/+$/, "");
+    const subPath = fullPath.replace(/^\/openclaw-workclaw\/sessions/, "").replace(/^\//, "") || "/";
+    const log = {
+      info: (msg) => api.logger?.info?.(`[SessionAPI] ${msg}`),
+      error: (msg) => api.logger?.error?.(`[SessionAPI] ${msg}`)
+    };
+    log?.info?.(`[SessionAPI] ${method} ${fullPath} (subPath: ${subPath})`);
+    if (method === "GET" && (subPath === "/" || subPath === "")) {
+      const sessionKey = url.searchParams.get("sessionKey");
+      if (sessionKey) {
+        const parsed = parseSessionKey(sessionKey);
+        const updatedAt = await getSessionLastUpdated(sessionKey, log);
+        sendJson$1(res, 200, {
+          ok: true,
+          session: {
+            sessionKey,
+            parsed,
+            lastUpdatedAt: updatedAt,
+            lastUpdatedAtFormatted: updatedAt ? new Date(updatedAt).toISOString() : null
+          }
+        });
+        return;
+      }
+      sendJson$1(res, 200, {
+        ok: true,
+        message: "Session Management API",
+        endpoints: {
+          "GET /sessions": "获取会话信息 (可选参数: sessionKey)",
+          "POST /sessions/reset": "重置/开启新会话 (参数: accountId + userId 或直接提供 sessionKey)",
+          "GET /sessions/store-path": "获取会话存储路径 (可选参数: agentId)"
+        }
+      });
+      return;
+    }
+    if (method === "POST" && subPath === "reset") {
+      const raw = await readRequestBody(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson$1(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const { accountId, userId, sessionKey: directSessionKey } = input;
+      let sessionKey;
+      if (directSessionKey) {
+        sessionKey = directSessionKey;
+      } else if (accountId && userId) {
+        sessionKey = buildSessionKey(accountId, userId);
+      } else {
+        sendJson$1(res, 400, {
+          ok: false,
+          error: "Missing required fields: either provide 'sessionKey' or both 'accountId' and 'userId'"
+        });
+        return;
+      }
+      const result = await resetSession(sessionKey, log);
+      if (result.success) {
+        sendJson$1(res, 200, {
+          ok: true,
+          message: result.message,
+          sessionKey
+        });
+      } else {
+        sendJson$1(res, 500, {
+          ok: false,
+          error: result.message,
+          sessionKey
+        });
+      }
+      return;
+    }
+    if (method === "GET" && subPath === "store-path") {
+      const agentId = url.searchParams.get("agentId") ?? void 0;
+      const storePath = getSessionStorePath(agentId, log);
+      if (storePath) {
+        sendJson$1(res, 200, {
+          ok: true,
+          storePath,
+          agentId: agentId ?? "default"
+        });
+      } else {
+        sendJson$1(res, 500, {
+          ok: false,
+          error: "Failed to resolve session store path"
+        });
+      }
+      return;
+    }
+    sendJson$1(res, 404, { ok: false, error: "Not Found" });
+  };
+}
+const execAsync = promisify(exec);
+function sendJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function createSkillsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    if (method === "GET") {
+      try {
+        const { stdout, stderr } = await execAsync("openclaw skills list --json", {
+          timeout: 1e4
+          // 10秒超时
+        });
+        if (stderr && !stdout) {
+          api.logger.error(`Skills list error: ${stderr}`);
+          sendJson(res, 500, { ok: false, error: "Failed to list skills" });
+          return;
+        }
+        let skillsData;
+        try {
+          skillsData = JSON.parse(stdout);
+        } catch {
+          const lines = stdout.split("\n");
+          const skills = lines.filter((line) => line.trim() && !line.includes("Skills")).map((line) => {
+            const parts = line.split(/\s{2,}/).map((p) => p.trim());
+            if (parts.length >= 3) {
+              return {
+                status: parts[0]?.includes("✓") ? "ready" : "missing",
+                name: parts[1],
+                description: parts[2],
+                source: parts[3] || "openclaw-bundled"
+              };
+            }
+            return null;
+          }).filter((s) => s !== null);
+          skillsData = {
+            total: skills.length,
+            ready: skills.filter((s) => s.status === "ready").length,
+            missing: skills.filter((s) => s.status === "missing").length,
+            skills
+          };
+        }
+        sendJson(res, 200, { ok: true, ...skillsData });
+        return;
+      } catch (error2) {
+        api.logger.error(`Skills API error: ${error2.message}`);
+        sendJson(res, 500, { ok: false, error: error2.message });
+        return;
+      }
+    }
+    sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+function parseRelativeTime(timeStr) {
+  const s = timeStr.trim().toLowerCase();
+  if (/^\d+$/.test(s)) {
+    return Number.parseInt(s, 10) * 6e4;
+  }
+  let totalMs = 0;
+  let matched = false;
+  const regex = /(\d+(?:\.\d+)?)\s*([dhms])/g;
+  let match;
+  while ((match = regex.exec(s)) !== null) {
+    matched = true;
+    const value = Number.parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+      case "d":
+        totalMs += value * 864e5;
+        break;
+      case "h":
+        totalMs += value * 36e5;
+        break;
+      case "m":
+        totalMs += value * 6e4;
+        break;
+      case "s":
+        totalMs += value * 1e3;
+        break;
+    }
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+function isCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  return parts.length >= 3 && parts.length <= 6;
+}
+function validateCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  if (parts.length < 3 || parts.length > 6) {
+    return { valid: false, error: `无效的 cron 表达式：字段数量不正确（期望 3-6 个字段，实际 ${parts.length} 个）` };
+  }
+  const patterns = [
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[01]?\d|2[0-3](-[01]?\d|2[0-3])?(\/\d|[01]?\d|2[0-3])?|L(-[01]?\d|2[0-3])?|W)?$/,
+    /^(\*|1[0-2]|0?[1-9](-[1-9]|0?[1-9])?(\/[1-9]|0?[1-9])?|L(-1[0-2]|0?[1-9])?|W)?$/,
+    /^([*LW]|[0-6](-[0-6])?(\/[0-6])?|L-[0-6])?$/,
+    /^(\*|L|(\*\/)?\d{1,2})?$/
+  ];
+  const fieldNames = ["秒", "分钟", "小时", "日期", "月份", "星期"];
+  for (let i = 0; i < parts.length && i < patterns.length; i++) {
+    const part = parts[i].trim();
+    const offset = parts.length - patterns.length;
+    if (i < offset)
+      continue;
+    if (!patterns[i].test(part)) {
+      return { valid: false, error: `无效的 cron 表达式：${fieldNames[i]}字段 "${part}" 格式不正确` };
+    }
+  }
+  return { valid: true };
+}
+function validateTimeFormat(timeStr) {
+  if (!timeStr || typeof timeStr !== "string" || timeStr.trim() === "") {
+    return { valid: false, error: "时间参数不能为空" };
+  }
+  const trimmed = timeStr.trim();
+  if (trimmed.startsWith("+") || /^\d+$/.test(trimmed) || /^\d+[dhms]/.test(trimmed)) {
+    const relativeMs = parseRelativeTime(trimmed);
+    if (relativeMs === null) {
+      return { valid: false, error: `无法解析相对时间 "${trimmed}"，支持的格式：5m、1h、1h30m、2d、30s 等` };
+    }
+    if (relativeMs < 3e4) {
+      return { valid: false, error: "提醒时间不能少于 30 秒" };
+    }
+    return { valid: true };
+  }
+  if (isCronExpression(trimmed)) {
+    return validateCronExpression(trimmed);
+  }
+  return { valid: false, error: `无法解析时间 "${trimmed}"，请使用相对时间（如 5m、1h）或 cron 表达式（如 0 8 * * *）` };
+}
+function relativeToCron(timeStr) {
+  const delayMs = parseRelativeTime(timeStr);
+  if (delayMs === null) {
+    return timeStr;
+  }
+  const futureTime = new Date(Date.now() + delayMs);
+  const seconds = futureTime.getSeconds();
+  const minutes = futureTime.getMinutes();
+  const hours = futureTime.getHours();
+  const dayOfMonth = futureTime.getDate();
+  const month = futureTime.getMonth() + 1;
+  return `${seconds} ${minutes} ${hours} ${dayOfMonth} ${month} *`;
+}
+const AddParamsSchema = {
+  type: "object",
+  properties: {
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["time", "name", "message"]
+};
+function json$a(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronAddParamsTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-add-params",
+      label: "智小途生成创建提醒参数",
+      description: `【核心工具】生成创建提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 从 cron 工具返回值中提取 jobId（返回格式：{"success": true, "jobId": "xxx"}）
+4. 必须调用 openclaw-workclaw-cron-add-sync 同步到后端
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 最终 CLI 命令必须使用 --cron 参数
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须使用 --cron 参数传递 cron 表达式
+
+⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
+      parameters: AddParamsSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-生成参数] 开始生成创建提醒参数 name=${p.name} time=${p.time}`);
+        if (!p.time) {
+          api.logger.warn("[智小途-生成参数] 缺少时间参数");
+          return json$a({ error: "time（时间）为必填参数" });
+        }
+        if (!p.name) {
+          api.logger.warn("[智小途-生成参数] 缺少任务名称参数");
+          return json$a({ error: "name（任务名称）为必填参数" });
+        }
+        if (!p.message) {
+          api.logger.warn("[智小途-生成参数] 缺少用户消息参数");
+          return json$a({ error: "message（用户消息）为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-生成参数] 无法获取账户 ID");
+          return json$a({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+        }
+        api.logger.info(`[智小途-生成参数] accountId=${accountId} name=${p.name}`);
+        const timeValidation = validateTimeFormat(p.time);
+        if (!timeValidation.valid) {
+          api.logger.warn(`[智小途-生成参数] 时间格式校验失败: ${timeValidation.error}`);
+          return json$a({ error: timeValidation.error });
+        }
+        const isCron = isCronExpression(p.time);
+        let isOneTime = false;
+        let cronExpr;
+        if (!isCron) {
+          isOneTime = true;
+          cronExpr = relativeToCron(p.time.trim());
+          api.logger.info(`[智小途-生成参数] 相对时间转换为 cron 表达式 cronExpr=${cronExpr}`);
+        } else {
+          cronExpr = p.time.trim();
+        }
+        const cronParams = {
+          action: "add",
+          account: accountId,
+          job: {
+            name: p.name,
+            schedule: {
+              kind: "cron",
+              expr: cronExpr,
+              tz: "Asia/Shanghai"
+            },
+            sessionTarget: "isolated",
+            wakeMode: "now",
+            deleteAfterRun: isOneTime ? true : void 0,
+            payload: {
+              kind: "agentTurn",
+              message: p.message
+            },
+            delivery: {
+              mode: "announce",
+              channel: "openclaw-workclaw"
+            }
+          }
+        };
+        api.logger.info(`[智小途-生成参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+        return json$a({
+          cronParams,
+          meta: {
+            accountId,
+            name: p.name,
+            kind: "cron",
+            expr: cronExpr,
+            message: p.message
+          },
+          summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`
+        });
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronAddParamsTool(api) {
+  api.registerTool(getOpenclawWorkclawCronAddParamsTool(api), {
+    name: "openclaw-workclaw-cron-add-params"
+  });
+}
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(fetchFn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const retryableErrors = options.retryableErrors ?? [
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "EAI_AGAIN"
+  ];
+  let lastError = "";
+  let attempts = 0;
+  for (let i = 0; i <= maxRetries; i++) {
+    attempts = i + 1;
+    try {
+      const data = await fetchFn();
+      return { data, attempts };
+    } catch (error2) {
+      lastError = error2.message || String(error2);
+      const isRetryable = retryableErrors.some(
+        (e) => lastError.toLowerCase().includes(e.toLowerCase())
+      );
+      if (i < maxRetries && isRetryable) {
+        const delay = retryDelayMs * 2 ** i;
+        await sleep(delay);
+        continue;
+      }
+      break;
+    }
+  }
+  return { error: lastError, attempts };
+}
+function sanitizePayload(payload) {
+  const sensitiveFields = [
+    "password",
+    "secret",
+    "token",
+    "authorization",
+    "appSecret",
+    "appSecret"
+  ];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(payload)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveFields.some((f) => lowerKey.includes(f))) {
+      sanitized[key] = "***";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizePayload(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+async function callBackendApi(api, accountId, path2, payload, options = {}) {
+  try {
+    const account = resolveWorkclawAccountWithCache({
+      cfg: api.config,
+      accountId
+    });
+    if (!account.configured) {
+      api.logger.error(`[智小途-定时任务] 账户未配置 accountId=${accountId}`);
+      return { success: false, error: "Account not configured" };
+    }
+    const accConfig = account.config;
+    const tokenCacheKey = accConfig.appKey || accountId;
+    const baseUrl = normalizeBaseUrl(accConfig.baseUrl);
+    api.logger.info(`[智小途-定时任务] 正在获取认证 token，accountId=${accountId}`);
+    const token = await getWorkclawAccessToken(tokenCacheKey, {
+      baseUrl: accConfig.baseUrl,
+      appKey: accConfig.appKey,
+      appSecret: accConfig.appSecret,
+      allowInsecureTls: accConfig.allowInsecureTls,
+      requestTimeout: accConfig.requestTimeout
+    });
+    const requestUrl = `${baseUrl}/open-apis${path2}`;
+    const sanitizedPayload = sanitizePayload(payload);
+    api.logger.info(`[智小途-定时任务] 调用接口 ${requestUrl}`);
+    api.logger.info(`[智小途-定时任务] 请求参数 ${JSON.stringify(sanitizedPayload)}`);
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const fetchResult = await fetchWithRetry(
+      () => doFetchJson(
+        requestUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`
+          },
+          body: JSON.stringify(payload)
+        },
+        accConfig.allowInsecureTls,
+        accConfig.requestTimeout
+      ),
+      { maxRetries }
+    );
+    if (fetchResult.error) {
+      api.logger.error(`[智小途-定时任务] 接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`);
+      return { success: false, error: fetchResult.error, attempts: fetchResult.attempts };
+    }
+    const data = fetchResult.data;
+    api.logger.info(`[智小途-定时任务] 接口响应（尝试 ${fetchResult.attempts} 次）: ${JSON.stringify(data)}`);
+    if (data?.code === 200 || data?.code === 0) {
+      return { success: true, data, attempts: fetchResult.attempts };
+    } else {
+      const errorMsg = data?.message || data?.msg || "Unknown error";
+      api.logger.error(`[智小途-定时任务] 接口返回错误 ${errorMsg}`);
+      return { success: false, error: errorMsg };
+    }
+  } catch (error2) {
+    api.logger.error(`[智小途-定时任务] 接口调用异常 ${error2.message}`);
+    return { success: false, error: error2.message };
+  }
+}
+async function callCronJobAdd(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 新增定时任务 jobId=${payload.jobId} name=${payload.name}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/add", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.messageId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobRemove(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 删除定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/del", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobUpdate(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 更新定时任务 jobId=${payload.jobId} name=${payload.name} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/update", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobEnabled(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 启用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/enabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobDisabled(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 禁用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/disabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobMessage(api, accountId, payload) {
+  api.logger.info(`[智小途-定时任务] 定时任务触发通知 jobId=${payload.jobId} message=${payload.message} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/message", {
+    clawJobId: payload.jobId,
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+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$9(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronAddSyncTool(api) {
+  return (ctx) => {
+    return {
+      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;
+        api.logger.info(`[智小途-同步创建] 开始同步 jobId=${p.jobId} name=${p.name}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-同步创建] 缺少 jobId 参数");
+          return json$9({ error: "jobId 为必填参数" });
+        }
+        const jobIdTrimmed = p.jobId.trim();
+        const parts = jobIdTrimmed.split(/\s+/);
+        const isCronExpression2 = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes("*");
+        if (isCronExpression2) {
+          api.logger.error(`[智小途-同步创建] jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`);
+          return json$9({
+            error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`
+          });
+        }
+        if (!p.name) {
+          api.logger.warn("[智小途-同步创建] 缺少 name 参数");
+          return json$9({ error: "name 为必填参数" });
+        }
+        if (!p.message) {
+          api.logger.warn("[智小途-同步创建] 缺少 message 参数");
+          return json$9({ error: "message 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-同步创建] 无法获取账户 ID");
+          return json$9({ 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$9({
+                code: 0,
+                message: "定时任务已创建并同步到后端",
+                data: {
+                  jobId: p.jobId,
+                  name: p.name,
+                  message: p.message,
+                  backendSynced: true
+                }
+              });
+            } else {
+              api.logger.error(`[智小途-同步创建] 后端同步失败 ${result.error}`);
+              return json$9({
+                code: -1,
+                error: result.error || "后端同步失败",
+                data: { jobId: p.jobId, name: p.name }
+              });
+            }
+          } catch (error2) {
+            api.logger.error(`[智小途-同步创建] 后端同步异常 ${error2.message}`);
+            return json$9({
+              code: -1,
+              error: error2.message,
+              data: { jobId: p.jobId, name: p.name }
+            });
+          }
+        } else {
+          api.logger.error(`[智小途-同步创建] 无法获取渠道配置，accountId=${accountId}`);
+          return json$9({ error: "无法获取渠道配置，请检查账户配置" });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronAddSyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronAddSyncTool(api), {
+    name: "openclaw-workclaw-cron-add-sync"
+  });
+}
+const DisableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$8(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronDisableParamsTool(api) {
+  return (ctx) => {
+    return {
+      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;
+        api.logger.info(`[智小途-生成禁用参数] 开始处理 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-生成禁用参数] 缺少 jobId 参数");
+          return json$8({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-生成禁用参数] 无法获取账户 ID");
+          return json$8({ 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$8({
+          cronParams,
+          meta: {
+            accountId,
+            jobId: p.jobId
+          },
+          summary: `⏸️ 提醒已禁用: jobId=${p.jobId}`
+        });
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronDisableParamsTool(api) {
+  api.registerTool(getOpenclawWorkclawCronDisableParamsTool(api), {
+    name: "openclaw-workclaw-cron-disable-params"
+  });
+}
+const DisableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$7(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronDisableSyncTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-disable-sync",
+      label: "智小途同步禁用提醒",
+      description: "将禁用定时任务同步到后端。在 cron 工具禁用任务后调用此工具同步后端。",
+      parameters: DisableSyncSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-同步禁用] 开始同步 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-同步禁用] 缺少 jobId 参数");
+          return json$7({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-同步禁用] 无法获取账户 ID");
+          return json$7({ 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$7({
+                code: 0,
+                message: "定时任务已禁用并同步到后端",
+                data: {
+                  jobId: p.jobId,
+                  backendSynced: true
+                }
+              });
+            } else {
+              api.logger.error(`[智小途-同步禁用] 后端同步失败 ${result.error}`);
+              return json$7({
+                code: -1,
+                error: result.error || "后端同步失败",
+                data: { jobId: p.jobId }
+              });
+            }
+          } catch (error2) {
+            api.logger.error(`[智小途-同步禁用] 后端同步异常 ${error2.message}`);
+            return json$7({
+              code: -1,
+              error: error2.message,
+              data: { jobId: p.jobId }
+            });
+          }
+        } else {
+          api.logger.error(`[智小途-同步禁用] 无法获取渠道配置，accountId=${accountId}`);
+          return json$7({ error: "无法获取渠道配置，请检查账户配置" });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronDisableSyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronDisableSyncTool(api), {
+    name: "openclaw-workclaw-cron-disable-sync"
+  });
+}
+const EnableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$6(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronEnableParamsTool(api) {
+  return (ctx) => {
+    return {
+      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;
+        api.logger.info(`[智小途-生成启用参数] 开始处理 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-生成启用参数] 缺少 jobId 参数");
+          return json$6({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-生成启用参数] 无法获取账户 ID");
+          return json$6({ 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$6({
+          cronParams,
+          meta: {
+            accountId,
+            jobId: p.jobId
+          },
+          summary: `✅ 提醒已启用: jobId=${p.jobId}`
+        });
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronEnableParamsTool(api) {
+  api.registerTool(getOpenclawWorkclawCronEnableParamsTool(api), {
+    name: "openclaw-workclaw-cron-enable-params"
+  });
+}
+const EnableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$5(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronEnableSyncTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-enable-sync",
+      label: "智小途同步启用提醒",
+      description: "将启用定时任务同步到后端。在 cron 工具启用任务后调用此工具同步后端。",
+      parameters: EnableSyncSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-同步启用] 开始同步 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-同步启用] 缺少 jobId 参数");
+          return json$5({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-同步启用] 无法获取账户 ID");
+          return json$5({ 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$5({
+                code: 0,
+                message: "定时任务已启用并同步到后端",
+                data: {
+                  jobId: p.jobId,
+                  backendSynced: true
+                }
+              });
+            } else {
+              api.logger.error(`[智小途-同步启用] 后端同步失败 ${result.error}`);
+              return json$5({
+                code: -1,
+                error: result.error || "后端同步失败",
+                data: { jobId: p.jobId }
+              });
+            }
+          } catch (error2) {
+            api.logger.error(`[智小途-同步启用] 后端同步异常 ${error2.message}`);
+            return json$5({
+              code: -1,
+              error: error2.message,
+              data: { jobId: p.jobId }
+            });
+          }
+        } else {
+          api.logger.error(`[智小途-同步启用] 无法获取渠道配置，accountId=${accountId}`);
+          return json$5({ error: "无法获取渠道配置，请检查账户配置" });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronEnableSyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronEnableSyncTool(api), {
+    name: "openclaw-workclaw-cron-enable-sync"
+  });
+}
+const NotifySchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: "OpenClaw 任务 ID（从上下文获取）"
+    },
+    message: {
+      type: "string",
+      description: "要发送的提醒内容"
+    }
+  },
+  required: ["jobId", "message"]
+};
+function json$4(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronNotifySyncTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-notify-sync",
+      label: "智小途定时任务触发通知",
+      description: `【系统最高优先级核心指令】当定时器时间到达时，必须立即调用此工具通知后端。`,
+      parameters: NotifySchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-定时触发] 开始处理 jobId=${p.jobId} message=${p.message}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-定时触发] 缺少 jobId 参数");
+          return json$4({ error: "jobId 为必填参数" });
+        }
+        if (!p.message) {
+          api.logger.warn("[智小途-定时触发] 缺少 message 参数");
+          return json$4({ error: "message 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-定时触发] 无法获取账户 ID");
+          return json$4({ 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$4({
+                code: 0,
+                message: "定时任务触发通知已发送",
+                data: {
+                  jobId: p.jobId,
+                  message: p.message,
+                  backendNotified: true
+                }
+              });
+            } else {
+              api.logger.error(`[智小途-定时触发] 通知后端失败 ${result.error}`);
+              return json$4({
+                code: -1,
+                error: result.error || "通知后端失败",
+                data: {
+                  jobId: p.jobId,
+                  message: p.message
+                }
+              });
+            }
+          } catch (error2) {
+            api.logger.error(`[智小途-定时触发] 通知后端异常 ${error2.message}`);
+            return json$4({
+              code: -1,
+              error: error2.message || "通知后端异常",
+              data: {
+                jobId: p.jobId,
+                message: p.message
+              }
+            });
+          }
+        } else {
+          api.logger.error(`[智小途-定时触发] 无法获取渠道配置，accountId=${accountId}`);
+          return json$4({ error: "无法获取渠道配置，请检查账户配置" });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronNotifySyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronNotifySyncTool(api), {
+    name: "openclaw-workclaw-cron-notify-sync"
+  });
+}
+const RemoveParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$3(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronRemoveParamsTool(api) {
+  return (ctx) => {
+    return {
+      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;
+        api.logger.info(`[智小途-生成删除参数] 开始处理 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-生成删除参数] 缺少 jobId 参数");
+          return json$3({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        const agentId = ctx?.agentId;
+        if (!accountId) {
+          api.logger.warn("[智小途-生成删除参数] 无法获取账户 ID");
+          return json$3({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+        }
+        if (!agentId) {
+          api.logger.warn("[智小途-生成删除参数] 无法获取智能体 ID");
+          return json$3({ 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$3({
+          cronParams,
+          meta: {
+            accountId,
+            agentId,
+            jobId: p.jobId
+          },
+          summary: `🗑️ 提醒已删除: jobId=${p.jobId}`
+        });
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronRemoveParamsTool(api) {
+  api.registerTool(getOpenclawWorkclawCronRemoveParamsTool(api), {
+    name: "openclaw-workclaw-cron-remove-params"
+  });
+}
+const RemoveSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$2(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronRemoveSyncTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-remove-sync",
+      label: "智小途同步删除提醒",
+      description: "【后端同步步骤】将删除定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-remove-params 执行后调用此工具完成同步。",
+      parameters: RemoveSyncSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-同步删除] 开始同步 jobId=${p.jobId}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-同步删除] 缺少 jobId 参数");
+          return json$2({ error: "jobId 为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        if (!accountId) {
+          api.logger.warn("[智小途-同步删除] 无法获取账户 ID");
+          return json$2({ 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$2({
+                code: 0,
+                message: "定时任务已删除并同步到后端",
+                data: {
+                  jobId: p.jobId,
+                  backendSynced: true
+                }
+              });
+            } else {
+              api.logger.error(`[智小途-同步删除] 后端同步失败 ${result.error}`);
+              return json$2({
+                code: -1,
+                error: result.error || "后端同步失败",
+                data: { jobId: p.jobId }
+              });
+            }
+          } catch (error2) {
+            api.logger.error(`[智小途-同步删除] 后端同步异常 ${error2.message}`);
+            return json$2({
+              code: -1,
+              error: error2.message,
+              data: { jobId: p.jobId }
+            });
+          }
+        } else {
+          api.logger.error(`[智小途-同步删除] 无法获取渠道配置，accountId=${accountId}`);
+          return json$2({ error: "无法获取渠道配置，请检查账户配置" });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronRemoveSyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronRemoveSyncTool(api), {
+    name: "openclaw-workclaw-cron-remove-sync"
+  });
+}
+const UpdateParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["jobId", "time", "name", "message"]
+};
+function json$1(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronUpdateParamsTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-update-params",
+      label: "智小途生成修改提醒参数",
+      description: `【核心工具】生成修改提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 必须调用 openclaw-workclaw-cron-update-sync 同步到后端
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "10m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 最终 CLI 命令必须使用 --cron 参数
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须使用 --cron 参数传递 cron 表达式
+
+⚠️ 必须从 cron 工具返回值中确认更新成功`,
+      parameters: UpdateParamsSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-生成修改参数] 开始处理 jobId=${p.jobId} name=${p.name} time=${p.time}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-生成修改参数] 缺少 jobId 参数");
+          return json$1({ error: "jobId 为必填参数" });
+        }
+        if (!p.time) {
+          api.logger.warn("[智小途-生成修改参数] 缺少时间参数");
+          return json$1({ error: "time（时间）为必填参数" });
+        }
+        if (!p.name) {
+          api.logger.warn("[智小途-生成修改参数] 缺少任务名称参数");
+          return json$1({ error: "name（任务名称）为必填参数" });
+        }
+        if (!p.message) {
+          api.logger.warn("[智小途-生成修改参数] 缺少提醒内容参数");
+          return json$1({ error: "message（提醒内容）为必填参数" });
+        }
+        const accountId = ctx?.agentAccountId;
+        const name = p.name;
+        const message = p.message;
+        const time = p.time;
+        if (!accountId) {
+          api.logger.warn("[智小途-生成修改参数] 无法获取账户 ID");
+          return json$1({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+        }
+        api.logger.info(`[智小途-生成修改参数] accountId=${accountId} jobId=${p.jobId}`);
+        const timeValidation = validateTimeFormat(time);
+        if (!timeValidation.valid) {
+          api.logger.warn(`[智小途-生成修改参数] 时间格式校验失败: ${timeValidation.error}`);
+          return json$1({ error: timeValidation.error });
+        }
+        const isCron = isCronExpression(time);
+        let isOneTime = false;
+        let cronExpr;
+        if (!isCron) {
+          isOneTime = true;
+          cronExpr = relativeToCron(time.trim());
+          api.logger.info(`[智小途-生成修改参数] 相对时间转换为绝对时间 cron 表达式 cronExpr=${cronExpr}`);
+        } else {
+          cronExpr = time.trim();
+        }
+        const cronParams = {
+          action: "update",
+          account: accountId,
+          jobId: p.jobId,
+          job: {
+            name,
+            schedule: {
+              kind: "cron",
+              expr: cronExpr,
+              tz: "Asia/Shanghai"
+            },
+            sessionTarget: "isolated",
+            wakeMode: "now",
+            deleteAfterRun: isOneTime ? true : void 0,
+            payload: {
+              kind: "agentTurn",
+              message
+            },
+            delivery: {
+              mode: "announce",
+              channel: "openclaw-workclaw"
+            }
+          }
+        };
+        api.logger.info(`[智小途-生成修改参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+        return json$1({
+          cronParams,
+          meta: {
+            accountId,
+            jobId: p.jobId,
+            name,
+            kind: "cron",
+            expr: cronExpr,
+            message
+          },
+          summary: `✅ 提醒已修改: "${name}" (${time})`
+        });
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronUpdateParamsTool(api) {
+  api.registerTool(getOpenclawWorkclawCronUpdateParamsTool(api), {
+    name: "openclaw-workclaw-cron-update-params"
+  });
+}
+const UpdateSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型（仅支持 cron）",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式（kind=cron 时必填）"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function getOpenclawWorkclawCronUpdateSyncTool(api) {
+  return (ctx) => {
+    return {
+      name: "openclaw-workclaw-cron-update-sync",
+      label: "智小途同步修改提醒",
+      description: "将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。",
+      parameters: UpdateSyncSchema,
+      execute: async (_toolCallId, params) => {
+        const p = params;
+        api.logger.info(`[智小途-同步修改] 开始同步 jobId=${p.jobId} name=${p.name}`);
+        if (!p.jobId) {
+          api.logger.warn("[智小途-同步修改] 缺少 jobId 参数");
+          return json({ error: "jobId 为必填参数" });
+        }
+        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;
+        const channelUserId = ctx?.From;
+        if (!accountId) {
+          api.logger.warn("[智小途-同步修改] 无法获取账户 ID");
+          return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+        }
+        const accountConfig = resolveWorkclawAccountWithCache({
+          cfg: ctx.config,
+          accountId
+        });
+        const channelAgentId = accountConfig.configured ? String(accountConfig.config.agentId) : "0";
+        api.logger.info(`[智小途-同步修改] accountId=${accountId} channelUserId=${channelUserId} channelAgentId=${channelAgentId}`);
+        try {
+          const result = await callCronJobUpdate(api, accountId, {
+            jobId: p.jobId,
+            name: p.name,
+            kind: p.kind,
+            expr: p.expr,
+            message: p.message,
+            agentId: 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 (error2) {
+          api.logger.error(`[智小途-同步修改] 后端同步异常 ${error2.message}`);
+          return json({
+            code: -1,
+            error: error2.message,
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      }
+    };
+  };
+}
+function registerOpenclawWorkclawCronUpdateSyncTool(api) {
+  api.registerTool(getOpenclawWorkclawCronUpdateSyncTool(api), {
+    name: "openclaw-workclaw-cron-update-sync"
+  });
+}
+function registerAllOpenclawWorkclawCronTools(api) {
+  registerOpenclawWorkclawCronAddParamsTool(api);
+  registerOpenclawWorkclawCronRemoveParamsTool(api);
+  registerOpenclawWorkclawCronUpdateParamsTool(api);
+  registerOpenclawWorkclawCronEnableParamsTool(api);
+  registerOpenclawWorkclawCronDisableParamsTool(api);
+  registerOpenclawWorkclawCronAddSyncTool(api);
+  registerOpenclawWorkclawCronRemoveSyncTool(api);
+  registerOpenclawWorkclawCronUpdateSyncTool(api);
+  registerOpenclawWorkclawCronEnableSyncTool(api);
+  registerOpenclawWorkclawCronDisableSyncTool(api);
+  registerOpenclawWorkclawCronNotifySyncTool(api);
+}
+function formatToolParams(toolName, params) {
+  if (!params || typeof params !== "object") {
+    return "";
+  }
+  const normalizedToolName = (toolName || "").toLowerCase().trim();
+  const p = params;
+  try {
+    if (normalizedToolName === "exec" || normalizedToolName === "bash" || normalizedToolName === "shell") {
+      const cmd = p.command || p.cmd;
+      if (cmd)
+        return `command: ${String(cmd).slice(0, 200)}`;
+    } else if (normalizedToolName === "read" || normalizedToolName === "file_read" || normalizedToolName === "view") {
+      const p2 = p.path;
+      if (p2)
+        return `path: ${p2}`;
+    } else if (normalizedToolName === "write" || normalizedToolName === "file_write" || normalizedToolName === "edit" || normalizedToolName === "patch") {
+      const p2 = p.path;
+      if (p2)
+        return `path: ${p2}`;
+    } else if (normalizedToolName === "web_fetch" || normalizedToolName === "fetch" || normalizedToolName === "http_get" || normalizedToolName === "http_request" || normalizedToolName === "open_url" || normalizedToolName === "browser_open" || normalizedToolName === "open") {
+      const u = p.url;
+      if (u)
+        return `url: ${u}`;
+    } else if (normalizedToolName === "search" || normalizedToolName === "web_search" || normalizedToolName === "google_search" || normalizedToolName === "browser_search" || normalizedToolName === "browser.search") {
+      const q = p.query || p.q || p.search;
+      if (q)
+        return `query: ${q}`;
+    } else if (normalizedToolName === "image_generate" || normalizedToolName === "generate_image" || normalizedToolName === "dalle" || normalizedToolName === "text_to_image") {
+      const prompt = p.prompt;
+      if (prompt)
+        return `prompt: ${String(prompt).slice(0, 200)}`;
+    } else if (normalizedToolName === "code_interpreter" || normalizedToolName === "python" || normalizedToolName === "jupyter") {
+      const code = p.code;
+      if (code)
+        return `code: ${String(code).slice(0, 200)}`;
+    } else if (normalizedToolName === "mcp_deliver" || normalizedToolName === "deliver") {
+      const target = p.target || p.to;
+      if (target)
+        return `target: ${target}`;
+    } else {
+      const entries = Object.entries(p);
+      if (entries.length > 0) {
+        return entries.map(([k, v]) => {
+          const vStr = typeof v === "string" ? v : JSON.stringify(v);
+          return vStr.length > 100 ? `${k}: ${vStr.slice(0, 100)}...` : `${k}: ${vStr}`;
+        }).join("\n");
+      }
+    }
+  } catch {
+    return String(params);
+  }
+  return "";
+}
+function formatToolOutput(toolName, params, _result) {
+  return formatToolParams(toolName, params);
+}
+function registerToolHooks(api) {
+  api.on("agent_end", (event, ctx) => {
+    const { runId } = ctx || {};
+    if (runId) {
+      deleteToolContext(runId);
+      api.logger?.info?.(`[ToolHook] agent_end runId=${runId} cleaned up`);
+    }
+    return event;
+  });
+  api.on("before_tool_call", (event, _ctx) => {
+    api.logger?.info?.(`[ToolHook] before_tool_call event=${JSON.stringify(event)}`);
+  });
+  api.on("after_tool_call", (event, _ctx) => {
+    api.logger?.info?.(`[ToolHook] after_tool_call event=${JSON.stringify(event)}`);
+    const { runId, toolCallId, toolName, params, result } = event || {};
+    const toolCtx = runId ? getToolContext(runId) : void 0;
+    if (toolCtx && result) {
+      const content = formatToolOutput(toolName, params);
+      if (content) {
+        try {
+          const cfg = getWorkclawRuntime().config.loadConfig();
+          const formattedToolOutput = {
+            name: getToolResultHint(toolName),
+            toolName,
+            content,
+            state: "result"
+          };
+          sendMessageWorkclaw({
+            cfg,
+            to: toolCtx.target,
+            text: JSON.stringify(formattedToolOutput),
+            msgType: "26",
+            accountId: toolCtx.accountId,
+            openConversationId: toolCtx.openConversationId,
+            agentId: toolCtx.agentId,
+            replyToMessageId: toolCtx.replyToMessageId,
+            last: false,
+            source: "after_tool_call"
+          }).catch((err) => {
+            api.logger?.error?.(`[ToolHook] after_tool_call push failed: ${err}`);
+          });
+          api.logger?.info?.(`[ToolHook] after_tool_call pushed for toolName=${toolName}`);
+        } catch (err) {
+          api.logger?.error?.(`[ToolHook] after_tool_call push failed: ${err}`);
+        }
+      }
+    }
+    if (runId && toolCallId) {
+      setToolCallIdToRunIdMapping(toolCallId, runId);
+    }
+    return event;
+  });
+  api.on("tool_result_persist", (event, _ctx) => {
+    return { message: event.message };
+  });
+  api.logger?.info?.(`[ToolHook] Tool execution hooks registered`);
+}
+const templateNames = ["SOUL.md", "IDENTITY.md"];
+function getPluginDir() {
+  try {
+    const url = import.meta.url;
+    if (!url.startsWith("file://")) {
+      return path.dirname(url);
+    }
+    return path.dirname(fileURLToPath(url));
+  } catch {
+    return process$1.cwd();
+  }
+}
+async function writeFileIfMissing(filePath, content) {
+  try {
+    await writeFile(filePath, content, { encoding: "utf-8", flag: "wx" });
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "EEXIST") {
+      return;
+    }
+    throw error2;
+  }
+}
+async function releaseTemplates(api) {
+  const workspaceDir = resolveWorkspaceDir(api);
+  getWorkclawLogger().info(`workspaceDir: ${workspaceDir}`);
+  const currentDir = getPluginDir();
+  const templatesDir = path.join(
+    currentDir.endsWith("dist") ? path.dirname(currentDir) : currentDir,
+    "templates"
+  );
+  const shouldOverwrite = isDefaultWorkspace(api);
+  await mkdir(workspaceDir, { recursive: true });
+  await Promise.all(
+    templateNames.map(async (name) => {
+      const sourcePath = path.join(templatesDir, name);
+      const targetPath = path.join(workspaceDir, name);
+      const content = await readFile(sourcePath, "utf-8");
+      if (shouldOverwrite) {
+        await writeFile(targetPath, content, { encoding: "utf-8" });
+      } else {
+        await writeFileIfMissing(targetPath, content);
+      }
+    })
+  );
+  api.logger?.info?.(`openclaw-workclaw templates ready: ${workspaceDir}`);
+}
+const index = defineChannelPluginEntry({
+  id: "openclaw-workclaw",
+  name: "智小途",
+  description: "智小途企业通讯平台 OpenClaw 渠道插件，支持消息收发、定时任务、工具调用等",
+  configSchema: emptyPluginConfigSchema(),
+  plugin: workclawPlugin,
+  registerFull(api) {
+    setWorkclawRuntime(api.runtime);
+    registerAllOpenclawWorkclawCronTools(api);
+    registerToolHooks(api);
+    api.registerService({
+      id: "openclaw-workclaw-templates",
+      start: async () => {
+        await releaseTemplates(api);
+      }
+    });
+    api.registerHttpRoute({
+      path: "/openclaw-workclaw/workspace/prompts",
+      handler: createPromptsApiHandler(api),
+      auth: "plugin"
+    });
+    api.registerHttpRoute({
+      path: "/openclaw-workclaw/accounts",
+      handler: createAccountsApiHandler(api),
+      auth: "plugin"
+    });
+    api.registerHttpRoute({
+      path: "/openclaw-workclaw/skills",
+      handler: createSkillsApiHandler(api),
+      auth: "plugin"
+    });
+    api.registerHttpRoute({
+      path: "/openclaw-workclaw/sessions",
+      handler: createSessionApiHandler(api),
+      auth: "plugin",
+      match: "prefix"
+    });
+  }
+});
+export {
+  index as default
+};