@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/setup-surface.js

@@ -0,0 +1,338 @@
+import { t as formatDocsLink } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/links-BlUEqVE8.js";
+import "node:path";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import { t as DEFAULT_ACCOUNT_ID } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/account-id-C6v13Xic.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-helpers-ChrkNnYE.js";
+import { D as patchTopLevelChannelConfigSection } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-wizard-helpers-DnMkYslk.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-jRxy02_4.js";
+import "node:fs/promises";
+import { inspectWorkclawCredentials, resolveDefaultWorkclawAccountId } from "./accounts.js";
+import { doFetchJson } from "./connection/workclaw-client.js";
+const channel = "openclaw-workclaw";
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function resolveSetupApiBases(cfg) {
+  const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+  const configuredBaseUrl = normalizeString(workclawCfg?.baseUrl) ?? normalizeString(process.env.WORKCLAW_BASE_URL);
+  const configuredAuthBaseUrl = normalizeString(process.env.WORKCLAW_AUTH_BASE_URL);
+  const configuredOpenApiBaseUrl = normalizeString(process.env.WORKCLAW_OPEN_API_BASE_URL);
+  const defaultAuthBaseUrl = "https://workbrain.cn/backend-api";
+  const defaultOpenApiBaseUrl = `${defaultAuthBaseUrl}/open-apis`;
+  const fromBaseUrl = (() => {
+    if (!configuredBaseUrl) {
+      return null;
+    }
+    const normalized = trimTrailingSlash(configuredBaseUrl);
+    if (normalized.endsWith("/open-apis")) {
+      return {
+        authBaseUrl: normalized.slice(0, -"/open-apis".length),
+        openApiBaseUrl: normalized
+      };
+    }
+    return {
+      authBaseUrl: normalized,
+      openApiBaseUrl: `${normalized}/open-apis`
+    };
+  })();
+  return {
+    authBaseUrl: trimTrailingSlash(
+      configuredAuthBaseUrl ?? fromBaseUrl?.authBaseUrl ?? defaultAuthBaseUrl
+    ),
+    openApiBaseUrl: trimTrailingSlash(
+      configuredOpenApiBaseUrl ?? fromBaseUrl?.openApiBaseUrl ?? defaultOpenApiBaseUrl
+    ),
+    allowInsecureTls: workclawCfg?.allowInsecureTls,
+    requestTimeout: workclawCfg?.requestTimeout
+  };
+}
+function isWorkclawConfigured(cfg) {
+  const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+  const isConfigured = (value) => {
+    const asString = normalizeString(value);
+    return !!asString;
+  };
+  const topLevelConfigured = isConfigured(workclawCfg?.appKey) && isConfigured(workclawCfg?.appSecret);
+  const accountConfigured = Object.values(workclawCfg?.accounts ?? {}).some((account) => {
+    if (!account || typeof account !== "object") {
+      return false;
+    }
+    const hasOwnAppKey = Object.prototype.hasOwnProperty.call(account, "appKey");
+    const hasOwnAppSecret = Object.prototype.hasOwnProperty.call(account, "appSecret");
+    const accountAppKeyConfigured = hasOwnAppKey ? isConfigured(account.appKey) : isConfigured(workclawCfg?.appKey);
+    const accountSecretConfigured = hasOwnAppSecret ? isConfigured(account.appSecret) : isConfigured(workclawCfg?.appSecret);
+    return accountAppKeyConfigured && accountSecretConfigured;
+  });
+  return topLevelConfigured || accountConfigured;
+}
+function patchWorkclawConfig(cfg, accountId, patch) {
+  const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return patchTopLevelChannelConfigSection({
+      cfg,
+      channel,
+      enabled: true,
+      patch
+    });
+  }
+  const nextAccountPatch = {
+    ...workclawCfg?.accounts?.[accountId],
+    enabled: true,
+    ...patch
+  };
+  return patchTopLevelChannelConfigSection({
+    cfg,
+    channel,
+    enabled: true,
+    patch: {
+      accounts: {
+        ...workclawCfg?.accounts,
+        [accountId]: nextAccountPatch
+      }
+    }
+  });
+}
+async function noteWorkclawCredentialHelp(prompter) {
+  await prompter.note(
+    [
+      "智小途插件安装引导",
+      "",
+      "准备事项:",
+      "1. 访问 workbrain.cn 获取 App Key 和 App Secret",
+      "2. 确保您的账号已开通智小途服务",
+      "3. 准备好您的手机号（用于获取配置信息）",
+      "",
+      `文档: ${formatDocsLink("/channels/openclaw-workclaw", "智小途")}`
+    ].join("\n"),
+    "智小途配置"
+  );
+}
+async function promptWorkclawAppKey(params) {
+  return (await params.prompter.text({
+    message: "智小途 App Key",
+    initialValue: params.initialValue,
+    validate: (value) => value?.trim() ? void 0 : "App Key 不能为空"
+  })).trim();
+}
+async function promptWorkclawAppSecret(params) {
+  return (await params.prompter.text({
+    message: "智小途 App Secret",
+    initialValue: params.initialValue,
+    validate: (value) => value?.trim() ? void 0 : "App Secret 不能为空"
+  })).trim();
+}
+async function promptWorkclawPhone(params) {
+  return (await params.prompter.text({
+    message: "智小途手机号",
+    initialValue: params.initialValue,
+    validate: (value) => {
+      if (!value?.trim())
+        return "手机号不能为空";
+      if (!/^1[3-9]\d{9}$/.test(value.trim()))
+        return "请输入正确的手机号格式";
+      return void 0;
+    }
+  })).trim();
+}
+async function fetchAgentInfoByPhone(cfg, appKey, appSecret, phone, prompter) {
+  prompter.note?.("正在通过手机号获取配置信息...", "获取配置");
+  try {
+    const { authBaseUrl, openApiBaseUrl, allowInsecureTls, requestTimeout } = resolveSetupApiBases(cfg);
+    const tokenData = await doFetchJson(
+      `${authBaseUrl}/authen/v1/access_token/internal`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          app_key: appKey,
+          app_secret: appSecret
+        })
+      },
+      allowInsecureTls,
+      requestTimeout
+    );
+    if (tokenData.code !== 200 || !tokenData.data?.accessToken) {
+      prompter.note?.(`获取 Token 失败: ${tokenData.message || "未知错误"}`, "获取配置");
+      return null;
+    }
+    const accessToken = tokenData.data.accessToken;
+    const agentData = await doFetchJson(
+      `${openApiBaseUrl}/instance/local/agentInf`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${accessToken}`
+        },
+        body: JSON.stringify({
+          appKey,
+          phone
+        })
+      },
+      allowInsecureTls,
+      requestTimeout
+    );
+    if (agentData.code !== 200 || !agentData.data) {
+      prompter.note?.(`获取配置信息失败: ${agentData.message || "未知错误"}`, "获取配置");
+      return null;
+    }
+    prompter.note?.(`成功获取配置信息`, "获取配置");
+    return {
+      agentId: agentData.data.agentId,
+      userId: agentData.data.userId
+    };
+  } catch (error) {
+    prompter.note?.(`获取配置失败: ${error.message}`, "获取配置");
+    return null;
+  }
+}
+async function runNewAppFlow(params) {
+  const { prompter } = params;
+  let next = params.cfg;
+  await noteWorkclawCredentialHelp(prompter);
+  const appKey = await promptWorkclawAppKey({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_APP_KEY)
+  });
+  const appSecret = await promptWorkclawAppSecret({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_APP_SECRET)
+  });
+  const phone = await promptWorkclawPhone({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_PHONE)
+  });
+  next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, {
+    appKey,
+    appSecret,
+    enabled: true
+  });
+  const agentInfo = await fetchAgentInfoByPhone(next, appKey, appSecret, phone, prompter);
+  if (agentInfo) {
+    const accountConfig = {
+      enabled: true
+    };
+    if (agentInfo.agentId) {
+      accountConfig.agentId = agentInfo.agentId;
+    }
+    if (agentInfo.userId) {
+      accountConfig.userId = agentInfo.userId;
+    }
+    next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, accountConfig);
+  }
+  next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, {
+    dmPolicy: "open",
+    allowFrom: ["*"]
+  });
+  await prompter.note("智小途配置完成!", "");
+  return { cfg: next };
+}
+async function runEditFlow(params) {
+  const workclawCfg = params.cfg.channels?.["openclaw-workclaw"];
+  const existingAppKey = workclawCfg?.appKey;
+  await params.prompter.note(
+    `当前配置的 App Key: ${existingAppKey ?? "(未配置)"}`,
+    "智小途配置"
+  );
+  const useExisting = await params.prompter.confirm({
+    message: `使用现有的智小途配置 (App Key: ${existingAppKey})?`,
+    initialValue: true
+  });
+  if (!useExisting) {
+    return runNewAppFlow(params);
+  }
+  await params.prompter.note("保持现有配置不变。", "");
+  return { cfg: params.cfg };
+}
+async function runProbeFlow(params) {
+  const workclawCfg = params.cfg.channels?.["openclaw-workclaw"];
+  const resolvedCredentials = inspectWorkclawCredentials(workclawCfg);
+  if (resolvedCredentials) {
+    try {
+      const probeResult = await resolvedCredentials();
+      params.prompter.note(
+        `智小途连接测试成功! ${probeResult.botName ? `Bot名称: ${probeResult.botName}` : ""}`,
+        "连接测试"
+      );
+    } catch {
+      params.prompter.note("智小途连接测试失败，请检查配置。", "连接测试");
+    }
+  }
+  return params.cfg;
+}
+const workclawSetupWizard = {
+  channel,
+  resolveAccountIdForConfigure: ({ accountOverride, defaultAccountId, cfg }) => (typeof accountOverride === "string" && accountOverride.trim() ? accountOverride.trim() : void 0) ?? resolveDefaultWorkclawAccountId(cfg) ?? defaultAccountId,
+  resolveShouldPromptAccountIds: () => false,
+  status: {
+    configuredLabel: "已配置",
+    unconfiguredLabel: "需要配置",
+    configuredHint: "已配置",
+    unconfiguredHint: "需要凭证",
+    configuredScore: 2,
+    unconfiguredScore: 0,
+    resolveConfigured: ({ cfg }) => isWorkclawConfigured(cfg),
+    resolveStatusLines: async ({ cfg, configured }) => {
+      const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+      const resolvedCredentials = inspectWorkclawCredentials(workclawCfg);
+      let probeResult = null;
+      if (configured && resolvedCredentials) {
+        try {
+          probeResult = await resolvedCredentials();
+        } catch {
+        }
+      }
+      if (!configured) {
+        return ["智小途: 需要 App Key 和 App Secret"];
+      }
+      if (probeResult?.ok) {
+        return [`智小途: 已连接${probeResult.botName ? ` (${probeResult.botName})` : ""}`];
+      }
+      return ["智小途: 已配置 (连接未验证)"];
+    }
+  },
+  prepare: async ({ cfg, credentialValues }) => {
+    const alreadyConfigured = isWorkclawConfigured(cfg);
+    if (alreadyConfigured) {
+      return {
+        credentialValues: { ...credentialValues, _flow: "edit" }
+      };
+    }
+    return {
+      credentialValues: { ...credentialValues, _flow: "new" }
+    };
+  },
+  credentials: [],
+  finalize: async ({ cfg, prompter, options, credentialValues }) => {
+    const flow = credentialValues._flow ?? "new";
+    if (flow === "edit") {
+      const result = await runEditFlow({ cfg, prompter });
+      if (result === null) {
+        return { cfg };
+      }
+      cfg = result.cfg;
+    } else {
+      cfg = (await runNewAppFlow({ cfg, prompter })).cfg;
+    }
+    await runProbeFlow({ cfg, prompter });
+    return { cfg };
+  },
+  disable: (cfg) => patchTopLevelChannelConfigSection({
+    cfg,
+    channel,
+    patch: { enabled: false }
+  })
+};
+export {
+  patchWorkclawConfig,
+  workclawSetupWizard
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/api/index.js

@@ -0,0 +1,184 @@
+import { resolveWorkclawAccountWithCache } from "../../../accounts.js";
+import { normalizeBaseUrl, getWorkclawAccessToken, doFetchJson } from "../../../connection/workclaw-client.js";
+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 (error) {
+      lastError = error.message || String(error);
+      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, path, 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${path}`;
+    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 (error) {
+    api.logger.error(`[智小途-定时任务] 接口调用异常 ${error.message}`);
+    return { success: false, error: error.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 };
+}
+export {
+  callBackendApi,
+  callCronJobAdd,
+  callCronJobDisabled,
+  callCronJobEnabled,
+  callCronJobMessage,
+  callCronJobRemove,
+  callCronJobUpdate
+};

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

@@ -0,0 +1,29 @@
+import { registerOpenclawWorkclawCronAddParamsTool } from "./src/add/params.js";
+import { registerOpenclawWorkclawCronAddSyncTool } from "./src/add/sync.js";
+import { registerOpenclawWorkclawCronDisableParamsTool } from "./src/disable/params.js";
+import { registerOpenclawWorkclawCronDisableSyncTool } from "./src/disable/sync.js";
+import { registerOpenclawWorkclawCronEnableParamsTool } from "./src/enable/params.js";
+import { registerOpenclawWorkclawCronEnableSyncTool } from "./src/enable/sync.js";
+import { registerOpenclawWorkclawCronNotifySyncTool } from "./src/notify/sync.js";
+import { registerOpenclawWorkclawCronRemoveParamsTool } from "./src/remove/params.js";
+import { registerOpenclawWorkclawCronRemoveSyncTool } from "./src/remove/sync.js";
+import { registerOpenclawWorkclawCronUpdateParamsTool } from "./src/update/params.js";
+import { registerOpenclawWorkclawCronUpdateSyncTool } from "./src/update/sync.js";
+function registerAllOpenclawWorkclawCronTools(api) {
+  api.logger?.info?.("[openclaw-workclaw] registering cron tools");
+  registerOpenclawWorkclawCronAddParamsTool(api);
+  registerOpenclawWorkclawCronRemoveParamsTool(api);
+  registerOpenclawWorkclawCronUpdateParamsTool(api);
+  registerOpenclawWorkclawCronEnableParamsTool(api);
+  registerOpenclawWorkclawCronDisableParamsTool(api);
+  registerOpenclawWorkclawCronAddSyncTool(api);
+  registerOpenclawWorkclawCronRemoveSyncTool(api);
+  registerOpenclawWorkclawCronUpdateSyncTool(api);
+  registerOpenclawWorkclawCronEnableSyncTool(api);
+  registerOpenclawWorkclawCronDisableSyncTool(api);
+  registerOpenclawWorkclawCronNotifySyncTool(api);
+  api.logger?.info?.("[openclaw-workclaw] cron tools registered");
+}
+export {
+  registerAllOpenclawWorkclawCronTools
+};

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

@@ -0,0 +1,129 @@
+import { validateTimeFormat, isCronExpression, relativeToCron } from "../../utils/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const AddParamsSchema = {
+  type: "object",
+  properties: {
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["time", "name", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddParamsTool(api) {
+  api.registerTool({
+    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 同步到后端
+
+🚫 禁止事项：
+- 禁止跳过本工具后直接手写 CLI 命令
+- 禁止自行拼接 cron 参数
+- 禁止在没有调用 openclaw-workclaw-cron-add-sync 的情况下宣布创建成功
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 下一步调用 OpenClaw cron 时必须使用本工具返回的 cron 表达式
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须沿用本工具返回的 cronParams 结果
+
+⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
+    parameters: AddParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-生成参数] 开始生成创建提醒参数 name=${p.name} time=${p.time}`);
+      if (!p.time) {
+        api.logger.warn("[智小途-生成参数] 缺少时间参数");
+        return json({ error: "time（时间）为必填参数" });
+      }
+      if (!p.name) {
+        api.logger.warn("[智小途-生成参数] 缺少任务名称参数");
+        return json({ error: "name（任务名称）为必填参数" });
+      }
+      if (!p.message) {
+        api.logger.warn("[智小途-生成参数] 缺少用户消息参数");
+        return json({ error: "message（用户消息）为必填参数" });
+      }
+      let accountId = ctx?.agentAccountId || "default";
+      api.logger.info(`[智小途-生成参数] accountId=${accountId} name=${p.name}`);
+      const timeValidation = validateTimeFormat(p.time);
+      if (!timeValidation.valid) {
+        api.logger.warn(`[智小途-生成参数] 时间格式校验失败: ${timeValidation.error}`);
+        return json({ 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({
+        cronParams,
+        meta: {
+          accountId,
+          name: p.name,
+          kind: "cron",
+          expr: cronExpr,
+          message: p.message
+        },
+        summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronAddParamsTool
+};