@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/dist/src/tools/openclaw-workclaw-cron/src/update/params.js

@@ -0,0 +1,164 @@
+/**
+ * 智小途定时任务工具 - 生成修改定时任务参数
+ */
+import { isCronExpression, relativeToCron, validateTimeFormat, } from '../../utils/index.js';
+/**
+ * 参数 Schema 定义
+ */
+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(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({ error: 'jobId 为必填参数' });
+                }
+                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（提醒内容）为必填参数' });
+                }
+                // 从 ctx 获取必要参数
+                const accountId = ctx?.agentAccountId;
+                const name = p.name;
+                const message = p.message;
+                const time = p.time;
+                // 校验必要参数
+                if (!accountId) {
+                    api.logger.warn('[智小途-生成修改参数] 无法获取账户 ID');
+                    return json({ 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({ error: timeValidation.error });
+                }
+                // 判断时间类型
+                const isCron = isCronExpression(time);
+                let isOneTime = false;
+                let cronExpr;
+                // 如果是相对时间（5m、1h 等），转换为绝对时间的 cron 表达式
+                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 : undefined,
+                        payload: {
+                            kind: 'agentTurn',
+                            message,
+                        },
+                        delivery: {
+                            mode: 'announce',
+                            channel: 'openclaw-workclaw',
+                        },
+                    },
+                };
+                api.logger.info(`[智小途-生成修改参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+                return json({
+                    cronParams,
+                    meta: {
+                        accountId,
+                        jobId: p.jobId,
+                        name,
+                        kind: 'cron',
+                        expr: cronExpr,
+                        message,
+                    },
+                    summary: `✅ 提醒已修改: "${name}" (${time})`,
+                });
+            },
+        };
+    };
+}
+/**
+ * 注册生成修改定时任务参数工具
+ */
+export function registerOpenclawWorkclawCronUpdateParamsTool(api) {
+    api.registerTool(getOpenclawWorkclawCronUpdateParamsTool(api), {
+        name: 'openclaw-workclaw-cron-update-params',
+    });
+}

package/dist/src/tools/openclaw-workclaw-cron/src/update/sync.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 智小途定时任务工具 - 同步修改定时任务到后端
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 同步修改定时任务参数
+ */
+export interface UpdateSyncParams {
+    jobId: string;
+    name: string;
+    kind: 'cron';
+    expr?: string;
+    message: string;
+}
+/**
+ * 注册同步修改定时任务到后端工具
+ */
+export declare function registerOpenclawWorkclawCronUpdateSyncTool(api: OpenClawPluginApi): void;

package/dist/src/tools/openclaw-workclaw-cron/src/update/sync.js

@@ -0,0 +1,135 @@
+/**
+ * 智小途定时任务工具 - 同步修改定时任务到后端
+ */
+import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
+import { callCronJobUpdate } from '../../api/index.js';
+/**
+ * 参数 Schema 定义
+ */
+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 为必填参数' });
+                }
+                // 从 ctx 获取必要参数
+                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 (error) {
+                    api.logger.error(`[智小途-同步修改] 后端同步异常 ${error.message}`);
+                    return json({
+                        code: -1,
+                        error: error.message,
+                        data: { jobId: p.jobId, name: p.name },
+                    });
+                }
+            },
+        };
+    };
+}
+/**
+ * 注册同步修改定时任务到后端工具
+ */
+export function registerOpenclawWorkclawCronUpdateSyncTool(api) {
+    api.registerTool(getOpenclawWorkclawCronUpdateSyncTool(api), {
+        name: 'openclaw-workclaw-cron-update-sync',
+    });
+}

package/dist/src/tools/openclaw-workclaw-cron/types/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 智小途定时任务工具 - 类型定义
+ */
+/**
+ * 后端接口请求体
+ */
+export interface CronJobPayload {
+    agentId: string;
+    messageId: string;
+    clawJobId: string;
+    name: string;
+    kind: 'cron';
+    expr?: string;
+    message: string;
+}
+/**
+ * OpenClaw cron 工具参数
+ */
+export interface OpenClawCronParams {
+    action: 'add' | 'list' | 'remove' | 'update' | 'enable' | 'disable';
+    job?: {
+        agentId: string;
+        name: string;
+        schedule: {
+            kind: 'cron';
+            expr: string;
+            tz: string;
+        };
+        sessionTarget: 'isolated';
+        wakeMode: 'now';
+        deleteAfterRun?: boolean;
+        payload: {
+            kind: 'agentTurn';
+            message: string;
+        };
+        delivery: {
+            mode: 'announce';
+            channel: string;
+            to: string;
+        };
+    };
+    jobId?: string;
+}
+/**
+ * 工具返回结果
+ */
+export interface CronToolResult {
+    success: boolean;
+    jobId?: string;
+    jobs?: any[];
+    error?: string;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * 智小途定时任务工具 - 类型定义
+ */
+export {};

package/dist/src/tools/openclaw-workclaw-cron/utils/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 智小途定时任务工具 - 工具函数
+ */
+/**
+ * 解析相对时间字符串
+ * 支持格式：5m, 1h, 1h30m, 2d, 30s, 1d2h30m 等
+ * @param timeStr - 时间字符串
+ * @returns 毫秒数，解析失败返回 null
+ */
+export declare function parseRelativeTime(timeStr: string): number | null;
+/**
+ * 判断是否为 cron 表达式
+ * @param timeStr - 时间字符串
+ * @returns 是否为 cron 表达式
+ */
+export declare function isCronExpression(timeStr: string): boolean;
+/**
+ * 校验 cron 表达式格式
+ * @param timeStr - 时间字符串
+ * @returns 校验结果和错误信息
+ */
+export declare function validateCronExpression(timeStr: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * 校验时间格式（相对时间或 cron 表达式）
+ * @param timeStr - 时间字符串
+ * @returns 校验结果和错误信息
+ */
+export declare function validateTimeFormat(timeStr: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * 将相对时间转换为标准 cron 表达式
+ * @param timeStr - 相对时间字符串，如 "5m", "1h", "2h30m"
+ * @returns 标准 cron 表达式（秒 分 时 日 月 星期），格式为 "SS MM HH DD MM *"
+ */
+export declare function relativeToCron(timeStr: string): string;

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

@@ -0,0 +1,122 @@
+/**
+ * 智小途定时任务工具 - 工具函数
+ */
+/**
+ * 解析相对时间字符串
+ * 支持格式：5m, 1h, 1h30m, 2d, 30s, 1d2h30m 等
+ * @param timeStr - 时间字符串
+ * @returns 毫秒数，解析失败返回 null
+ */
+export function parseRelativeTime(timeStr) {
+    const s = timeStr.trim().toLowerCase();
+    if (/^\d+$/.test(s)) {
+        return Number.parseInt(s, 10) * 60_000;
+    }
+    let totalMs = 0;
+    let matched = false;
+    const regex = /(\d+(?:\.\d+)?)\s*([dhms])/g;
+    let match;
+    // eslint-disable-next-line no-cond-assign
+    while ((match = regex.exec(s)) !== null) {
+        matched = true;
+        const value = Number.parseFloat(match[1]);
+        const unit = match[2];
+        switch (unit) {
+            case 'd':
+                totalMs += value * 86_400_000;
+                break;
+            case 'h':
+                totalMs += value * 3_600_000;
+                break;
+            case 'm':
+                totalMs += value * 60_000;
+                break;
+            case 's':
+                totalMs += value * 1_000;
+                break;
+        }
+    }
+    return matched ? Math.round(totalMs) : null;
+}
+/**
+ * 判断是否为 cron 表达式
+ * @param timeStr - 时间字符串
+ * @returns 是否为 cron 表达式
+ */
+export function isCronExpression(timeStr) {
+    const parts = timeStr.trim().split(/\s+/);
+    return parts.length >= 3 && parts.length <= 6;
+}
+/**
+ * 校验 cron 表达式格式
+ * @param timeStr - 时间字符串
+ * @returns 校验结果和错误信息
+ */
+export 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 };
+}
+/**
+ * 校验时间格式（相对时间或 cron 表达式）
+ * @param timeStr - 时间字符串
+ * @returns 校验结果和错误信息
+ */
+export 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 < 30_000) {
+            return { valid: false, error: '提醒时间不能少于 30 秒' };
+        }
+        return { valid: true };
+    }
+    if (isCronExpression(trimmed)) {
+        return validateCronExpression(trimmed);
+    }
+    return { valid: false, error: `无法解析时间 "${trimmed}"，请使用相对时间（如 5m、1h）或 cron 表达式（如 0 8 * * *）` };
+}
+/**
+ * 将相对时间转换为标准 cron 表达式
+ * @param timeStr - 相对时间字符串，如 "5m", "1h", "2h30m"
+ * @returns 标准 cron 表达式（秒 分 时 日 月 星期），格式为 "SS MM HH DD MM *"
+ */
+export 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} *`;
+}

package/dist/src/tools/openclaw-workclaw-system/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 智小途系统信息工具 - 统一出口
+ *
+ * 提供统一的工具注册入口，一次性注册所有系统信息相关工具
+ */
+/**
+ * 统一注册所有系统信息工具
+ * @param api - OpenClaw API 实例
+ */
+export declare function registerAllOpenclawWorkclawSystemTools(api: any): void;

package/{src/tools/openclaw-workclaw-system/index.ts → dist/src/tools/openclaw-workclaw-system/index.js}

@@ -1,17 +1,15 @@
-/**
- * 智小途系统信息工具 - 统一出口
- *
- * 提供统一的工具注册入口，一次性注册所有系统信息相关工具
- */
-
-import { registerOpenclawWorkclawSystemConfigTool } from './src/get/index.js'
-import { registerOpenclawWorkclawSystemTokenTool } from './src/token/index.js'
-
-/**
- * 统一注册所有系统信息工具
- * @param api - OpenClaw API 实例
- */
-export function registerAllOpenclawWorkclawSystemTools(api: any): void {
-  registerOpenclawWorkclawSystemConfigTool(api)
-  registerOpenclawWorkclawSystemTokenTool(api)
-}
+/**
+ * 智小途系统信息工具 - 统一出口
+ *
+ * 提供统一的工具注册入口，一次性注册所有系统信息相关工具
+ */
+import { registerOpenclawWorkclawSystemConfigTool } from './src/get/index.js';
+import { registerOpenclawWorkclawSystemTokenTool } from './src/token/index.js';
+/**
+ * 统一注册所有系统信息工具
+ * @param api - OpenClaw API 实例
+ */
+export function registerAllOpenclawWorkclawSystemTools(api) {
+    registerOpenclawWorkclawSystemConfigTool(api);
+    registerOpenclawWorkclawSystemTokenTool(api);
+}

package/dist/src/tools/openclaw-workclaw-system/src/get/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 智小途系统信息工具 - 获取系统配置信息
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 注册获取系统配置信息工具
+ */
+export declare function registerOpenclawWorkclawSystemConfigTool(api: OpenClawPluginApi): void;

package/dist/src/tools/openclaw-workclaw-system/src/get/index.js

@@ -0,0 +1,64 @@
+/**
+ * 智小途系统信息工具 - 获取系统配置信息
+ */
+import { resolveWorkclawAccountWithCache } from '../../../../accounts.js';
+/**
+ * 构造工具返回结果
+ */
+function json(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        details: data,
+    };
+}
+/**
+ * 获取系统配置信息工具
+ */
+function getOpenclawWorkclawSystemConfigTool(api) {
+    return (ctx) => {
+        return {
+            name: 'openclaw-workclaw-system-config',
+            label: '智小途获取系统信息',
+            description: '获取当前渠道的系统配置信息，包括 appKey、appSecret、agentId、userId 等',
+            execute: async () => {
+                api.logger.info('[智小途-系统信息] 开始获取系统配置信息');
+                const accountId = ctx?.agentAccountId;
+                if (!accountId) {
+                    api.logger.warn('[智小途-系统信息] 无法获取账户 ID');
+                    return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' });
+                }
+                api.logger.info(`[智小途-系统信息] accountId=${accountId}`);
+                const accountConfig = resolveWorkclawAccountWithCache({
+                    cfg: ctx.config,
+                    accountId,
+                });
+                if (!accountConfig.configured) {
+                    api.logger.error('[智小途-系统信息] 账户未配置');
+                    return json({ error: '账户未配置，请检查账户配置' });
+                }
+                const accConfig = accountConfig.config;
+                const result = {
+                    accountId,
+                    appKey: accConfig.appKey,
+                    appSecret: accConfig.appSecret,
+                    agentId: accConfig.agentId,
+                    userId: accConfig.userId,
+                };
+                api.logger.info(`[智小途-系统信息] 获取成功${JSON.stringify(result)}`);
+                return json({
+                    code: 0,
+                    message: '系统信息获取成功',
+                    data: result,
+                });
+            },
+        };
+    };
+}
+/**
+ * 注册获取系统配置信息工具
+ */
+export function registerOpenclawWorkclawSystemConfigTool(api) {
+    api.registerTool(getOpenclawWorkclawSystemConfigTool(api), {
+        name: 'openclaw-workclaw-system-config',
+    });
+}

package/dist/src/tools/openclaw-workclaw-system/src/token/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 智小途系统信息工具 - 获取用户 AccessToken
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 注册获取用户 AccessToken 工具
+ */
+export declare function registerOpenclawWorkclawSystemTokenTool(api: OpenClawPluginApi): void;