@ynhcj/xiaoyi-channel 0.0.72-beta → 0.0.72-next

package/dist/src/tools/login-token-tool.js

@@ -0,0 +1,136 @@
+// Login Token tool - 自动获取用户授权信息
+import { v4 as uuidv4 } from "uuid";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
+import { readFileSync, existsSync } from "fs";
+import { logger } from "../utils/logger.js";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 60000; // 1 minute
+const TOKEN_VALIDITY_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * get_login_token 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export const loginTokenTool = {
+    name: "get_login_token",
+    label: "Get Login Token",
+    description: "获取用户授权信息。当skill需要用户鉴权时调用此工具，工具会向用户端发送授权请求，等待用户完成授权后返回结果。请勿重复调用此工具。",
+    parameters: {
+        type: "object",
+        properties: {
+            clientId: {
+                type: "string",
+                description: "账号服务唯一标识，在执行具体skill过程中会提供",
+            },
+            skillName: {
+                type: "string",
+                description: "具体skill的名称",
+            },
+        },
+        required: ["clientId", "skillName"],
+    },
+    async execute(toolCallId, params) {
+        const { clientId, skillName } = params;
+        if (!clientId || typeof clientId !== "string" || clientId.trim() === "") {
+            throw new Error("Missing required parameter: clientId must be a non-empty string");
+        }
+        if (!skillName || typeof skillName !== "string" || skillName.trim() === "") {
+            throw new Error("Missing required parameter: skillName must be a non-empty string");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Login token tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+        const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+        // (1) Build and send getLoginToken artifact
+        const artifactId = uuidv4();
+        const artifact = {
+            taskId: currentTaskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: false,
+            artifact: {
+                artifactId,
+                parts: [
+                    {
+                        kind: "getLoginToken",
+                        clientId: clientId.trim(),
+                        skillName: skillName.trim(),
+                    },
+                ],
+            },
+        };
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: currentMessageId,
+            result: artifact,
+        };
+        const wsManager = getXYWebSocketManager(config);
+        const outboundMessage = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId,
+            taskId: currentTaskId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        logger.log(`[LOGIN_TOKEN] Sending getLoginToken artifact for clientId=${clientId}, skillName=${skillName}`);
+        await wsManager.sendMessage(sessionId, outboundMessage);
+        logger.log(`[LOGIN_TOKEN] Artifact sent successfully`);
+        // (2) Poll .xiaoyitoken.json every 5 seconds
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const poll = () => {
+                const elapsed = Date.now() - startTime;
+                if (elapsed >= TIMEOUT_MS) {
+                    // (4) Timeout after 1 minute
+                    logger.log(`[LOGIN_TOKEN] Timeout: failed to get login token for clientId=${clientId}`);
+                    resolve({
+                        content: [
+                            {
+                                type: "text",
+                                text: "获取用户授权失败",
+                            },
+                        ],
+                    });
+                    return;
+                }
+                try {
+                    if (existsSync(TOKEN_FILE_PATH)) {
+                        const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                        const tokens = JSON.parse(content);
+                        const match = tokens.find((t) => t.clientId === clientId.trim());
+                        if (match) {
+                            const tokenTime = Number(match.timestamp);
+                            const diff = Date.now() - tokenTime;
+                            if (diff <= TOKEN_VALIDITY_MS) {
+                                // (3) Found valid token
+                                logger.log(`[LOGIN_TOKEN] Successfully got login token for clientId=${clientId}`);
+                                resolve({
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "获取用户授权成功",
+                                        },
+                                    ],
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.log(`[LOGIN_TOKEN] Error reading token file: ${err}`);
+                }
+                // Not found or not valid, poll again after 5 seconds
+                setTimeout(poll, POLL_INTERVAL_MS);
+            };
+            // Start polling after 5 seconds
+            setTimeout(poll, POLL_INTERVAL_MS);
+        });
+    },
+};

package/dist/src/tools/modify-alarm-tool.js

@@ -20,23 +20,10 @@ export const modifyAlarmTool = {
     label: "Modify Alarm",
     description: `修改用户设备上已存在的闹钟。
 
-必需参数：
-- entityId: 闹钟的唯一标识符，必须先通过 search_alarm 或 create_alarm 工具获取
-
-可选参数（与创建闹钟的参数完全一致）：
-- alarmTime: 闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）
-- alarmTitle: 闹钟名称/标题
-- alarmState: 闹钟开启状态，0=关闭，1=开启
-- alarmSnoozeDuration: 小睡间隔（分钟），枚举值：5,10,15,20,25,30
-- alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10
-- alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30
-- daysOfWakeType: 闹钟响铃类型，枚举值：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日
-- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。
-
 使用流程：
 1. 先调用 search_alarm 工具查询闹钟，获取 entityId，
 2. 调用此工具修改闹钟，传入 entityId 和需要修改的参数
-3. 其余不涉及需改的参数，如果search_alarm 或 create_alarm的结果中有相应的值，需要一并填上，需要与原有的保持一致，防止不填采用默认值
+3. 其余不涉及修改的参数，如果search_alarm 或 create_alarm的结果中有相应的值，需要一并填上，需要与原有的保持一致，防止不填采用默认值
 
 注意事项：操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
 
@@ -46,40 +33,40 @@ export const modifyAlarmTool = {
         properties: {
             entityId: {
                 type: "string",
-                description: "闹钟的唯一标识符，必须先通过 search_alarm 或 create_alarm 工具获取",
+                description: "（必需）闹钟的唯一标识符，必须先通过 search_alarm 或 create_alarm 工具获取",
             },
             alarmTime: {
                 type: "string",
-                description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）",
+                description: "（可选）闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）",
             },
             alarmTitle: {
                 type: "string",
-                description: "闹钟名称/标题",
+                description: "（可选）闹钟名称/标题",
             },
             alarmState: {
                 type: "number",
-                description: "闹钟开启状态：0=关闭，1=开启",
+                description: "（可选）闹钟开启状态，枚举值：0=关闭，1=开启",
             },
             alarmSnoozeDuration: {
                 type: "number",
-                description: "小睡间隔（分钟），枚举值：5,10,15,20,25,30",
+                description: "（可选）小睡间隔（分钟），枚举值：5,10,15,20,25,30",
             },
             alarmSnoozeTotal: {
                 type: "number",
-                description: "再响次数，枚举值：0,1,3,5,10",
+                description: "（可选）再响次数，枚举值：0,1,3,5,10",
             },
             alarmRingDuration: {
                 type: "number",
-                description: "响铃时长（分钟），枚举值：1,5,10,15,20,30",
+                description: "（可选）响铃时长（分钟），枚举值：1,5,10,15,20,30",
             },
             daysOfWakeType: {
                 type: "number",
-                description: "闹钟响铃类型：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日",
+                description: "（可选）闹钟响铃类型，枚举值：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日",
             },
             daysOfWeek: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
+                description: "（可选）自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun",
             },
         },
         required: ["entityId"],

package/dist/src/tools/query-app-message-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export declare const queryAppMessageTool: any;

package/dist/src/tools/query-app-message-tool.js

@@ -0,0 +1,138 @@
+// QueryAppMessage tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export const queryAppMessageTool = {
+    name: "query_app_message",
+    label: "Query App Message",
+    description: `获取指定时间范围内的设备通知消息。适用于需要查询历史通知、按应用筛选通知、或仅查看未读通知的场景。支持按时间范围、应用包名、已读/未读状态进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "查询通知的起始时间（ISO 8601 字符串）。若endTime为空，则默认值为24小时前。",
+            },
+            endTime: {
+                type: "string",
+                description: "查询通知的结束时间（ISO 8601 字符串）。默认值为当前时间。",
+            },
+            packageName: {
+                type: "string",
+                description: "按应用名称过滤通知（例如「微信」「小红书」）。默认值为所有应用。",
+            },
+            state: {
+                type: "integer",
+                description: "通知的已读/未读状态。0 = 全部，1 = 仅未读。默认值为 0。",
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (params.startTime !== undefined)
+            intentParam.startTime = params.startTime;
+        if (params.endTime !== undefined)
+            intentParam.endTime = params.endTime;
+        if (params.packageName !== undefined)
+            intentParam.packageName = params.packageName;
+        if (params.state !== undefined) {
+            if (params.state !== 0 && params.state !== 1) {
+                throw new ToolInputError("state 参数只能为 0（全部）或 1（仅未读）");
+            }
+            intentParam.state = params.state;
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryAppMessage",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询通知消息超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryAppMessage") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询通知消息失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/query-memory-data-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询存储在设备本地的结构化记忆数据。
+ */
+export declare const queryMemoryDataTool: any;

package/dist/src/tools/query-memory-data-tool.js

@@ -0,0 +1,154 @@
+// QueryMemoryData tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+const VALID_CATEGORIES = ["ImportantDay", "Address", "Card", "ServiceOrder", "Event"];
+const VALID_SUB_CATEGORIES = {
+    ImportantDay: ["Birthday", "Anniversary", "RepaymentDate", "ExamDate", "SalaryDate", "BigDay"],
+    Card: [
+        "IDCard", "Passport", "DrivingLicense", "VehicleLicense", "EEPtoHKMO",
+        "EEPtoTW", "Invoice", "BusinessCard", "VehicleInspectionCertificate",
+        "SocialSecurityCard", "BankCard",
+    ],
+    ServiceOrder: ["FilmTicket", "HotelOrder", "TrainTicket", "AirTicket"],
+    Event: [
+        "Delicacy", "Work", "FamilyActivities", "Travel", "Training",
+        "Health", "Life", "Entertainment", "Calendar",
+    ],
+};
+/**
+ * 查询存储在设备本地的结构化记忆数据。
+ */
+export const queryMemoryDataTool = {
+    name: "query_memory_data",
+    label: "Query Memory Data",
+    description: `查询存储在设备本地的结构化记忆数据。适用于获取特定类别的个人信息，如重要日子、证件卡证、服务订单或日程事件。支持按分类、子分类进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            category: {
+                type: "string",
+                description: '按数据大类进行过滤。可选值为 ""、"ImportantDay"、"Address"、"Card"、"ServiceOrder"、"Event"。默认值为 ""。',
+            },
+            subCategory: {
+                description: '在指定 category 下的子类别过滤，默认值为""。支持字符串或字符串数组。',
+                oneOf: [
+                    { type: "string" },
+                    { type: "array", items: { type: "string" } },
+                ],
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const { category, subCategory } = params;
+        // Validate category
+        if (category && !VALID_CATEGORIES.includes(category)) {
+            throw new ToolInputError(`category 参数无效，可选值为：${VALID_CATEGORIES.join("、")}`);
+        }
+        // Validate subCategory when category is specified
+        if (category && subCategory && VALID_SUB_CATEGORIES[category]) {
+            const validValues = VALID_SUB_CATEGORIES[category];
+            const subValues = Array.isArray(subCategory) ? subCategory : [subCategory];
+            for (const sv of subValues) {
+                if (sv && !validValues.includes(sv)) {
+                    throw new ToolInputError(`category 为 "${category}" 时，subCategory 可选值为：${validValues.join("、")}`);
+                }
+            }
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (category)
+            intentParam.category = category;
+        if (subCategory !== undefined)
+            intentParam.subCategory = subCategory;
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryMemoryData",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询记忆数据超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryMemoryData") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询记忆数据失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/query-todo-task-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 获取指定时间范围内的全局待办任务列表。
+ */
+export declare const queryTodoTaskTool: any;

package/dist/src/tools/query-todo-task-tool.js

@@ -0,0 +1,133 @@
+// QueryTodoTask tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 获取指定时间范围内的全局待办任务列表。
+ */
+export const queryTodoTaskTool = {
+    name: "query_todo_task",
+    label: "Query Todo Task",
+    description: `获取指定时间范围内的全局待办任务列表。适用于需要查询历史任务、按完成状态筛选、或仅查看待处理任务的场景。支持按时间范围、任务状态进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+d. 当只传入 startTime 时，返回该时间点之后的所有任务；当只传入 endTime 时，返回该时间点之前的所有任务；两者都不传则返回所有时间段的任务。
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "查询创建时间大于此值的任务（ISO 8601 字符串，如 2024-01-01T00:00:00Z）。",
+            },
+            endTime: {
+                type: "string",
+                description: "查询创建时间小于此值的任务（ISO 8601 字符串，如 2024-01-31T23:59:59Z）。",
+            },
+            status: {
+                type: "string",
+                description: '任务完成状态过滤。可选值为 "all"、"completed"、"pending"。默认为 "all"。',
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const { status } = params;
+        if (status && !["all", "completed", "pending"].includes(status)) {
+            throw new ToolInputError('status 参数只能为 "all"、"completed" 或 "pending"');
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (params.startTime !== undefined)
+            intentParam.startTime = params.startTime;
+        if (params.endTime !== undefined)
+            intentParam.endTime = params.endTime;
+        if (status !== undefined)
+            intentParam.status = status;
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryTodoTask",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询待办任务超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryTodoTask") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询待办任务失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/save-file-to-phone-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY save file to phone tool - saves files to user's device file manager.
+ * Supports local file paths (auto-uploaded to get public URL) and public URLs.
+ */
+export declare const saveFileToPhoneTool: any;