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

package/dist/src/thread-bindings.js

@@ -0,0 +1,214 @@
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, unregisterSessionBindingAdapter, } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/text-runtime";
+const XY_THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.xyThreadBindingsState");
+const state = resolveGlobalSingleton(XY_THREAD_BINDINGS_STATE_KEY, () => ({
+    managersByAccountId: new Map(),
+    bindingsByAccountSession: new Map(),
+}));
+function getState() {
+    return state;
+}
+function resolveBindingKey(params) {
+    return `${params.accountId}:${params.sessionId}`;
+}
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toXYTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toSessionBindingRecord(record, defaults) {
+    const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
+    const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
+    const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null
+        ? Math.min(idleExpiresAt, maxAgeExpiresAt)
+        : (idleExpiresAt ?? maxAgeExpiresAt);
+    return {
+        bindingId: resolveBindingKey({
+            accountId: record.accountId,
+            sessionId: record.sessionId,
+        }),
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "xiaoyi-channel",
+            accountId: record.accountId,
+            conversationId: record.sessionId, // sessionId is the conversationId for Xiaoyi
+            parentConversationId: undefined, // Xiaoyi doesn't have parent conversations
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            lastActivityAt: record.lastActivityAt,
+            idleTimeoutMs: defaults.idleTimeoutMs,
+            maxAgeMs: defaults.maxAgeMs,
+        },
+    };
+}
+/**
+ * Creates a thread binding manager for Xiaoyi channel.
+ * Based on feishu implementation but simplified for single-account mode.
+ */
+export function createXYThreadBindingManager(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = getState().managersByAccountId.get(accountId);
+    if (existing) {
+        return existing;
+    }
+    const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const manager = {
+        accountId,
+        getBySessionId: (sessionId) => getState().bindingsByAccountSession.get(resolveBindingKey({ accountId, sessionId })),
+        listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountSession.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+        bindSession: ({ sessionId, targetKind, targetSessionKey, metadata, }) => {
+            const normalizedSessionId = sessionId.trim();
+            if (!normalizedSessionId || !targetSessionKey.trim()) {
+                return null;
+            }
+            const now = Date.now();
+            const record = {
+                accountId,
+                sessionId: normalizedSessionId,
+                targetKind: toXYTargetKind(targetKind),
+                targetSessionKey: targetSessionKey.trim(),
+                agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim()
+                    ? metadata.agentId.trim()
+                    : resolveAgentIdFromSessionKey(targetSessionKey),
+                boundAt: now,
+                lastActivityAt: now,
+            };
+            getState().bindingsByAccountSession.set(resolveBindingKey({ accountId, sessionId: normalizedSessionId }), record);
+            return record;
+        },
+        touchSession: (sessionId, at = Date.now()) => {
+            const key = resolveBindingKey({ accountId, sessionId });
+            const existingRecord = getState().bindingsByAccountSession.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            const updated = { ...existingRecord, lastActivityAt: at };
+            getState().bindingsByAccountSession.set(key, updated);
+            return updated;
+        },
+        unbindSession: (sessionId) => {
+            const key = resolveBindingKey({ accountId, sessionId });
+            const existingRecord = getState().bindingsByAccountSession.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            getState().bindingsByAccountSession.delete(key);
+            return existingRecord;
+        },
+        unbindBySessionKey: (targetSessionKey) => {
+            const removed = [];
+            for (const record of [...getState().bindingsByAccountSession.values()]) {
+                if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
+                    continue;
+                }
+                getState().bindingsByAccountSession.delete(resolveBindingKey({ accountId, sessionId: record.sessionId }));
+                removed.push(record);
+            }
+            return removed;
+        },
+        stop: () => {
+            for (const key of [...getState().bindingsByAccountSession.keys()]) {
+                if (key.startsWith(`${accountId}:`)) {
+                    getState().bindingsByAccountSession.delete(key);
+                }
+            }
+            getState().managersByAccountId.delete(accountId);
+            unregisterSessionBindingAdapter({
+                channel: "xiaoyi-channel",
+                accountId,
+                adapter: sessionBindingAdapter,
+            });
+        },
+    };
+    const sessionBindingAdapter = {
+        channel: "xiaoyi-channel",
+        accountId,
+        capabilities: {
+            placements: ["current"],
+        },
+        bind: async (input) => {
+            if (input.conversation.channel !== "xiaoyi-channel" || input.placement === "child") {
+                return null;
+            }
+            const bound = manager.bindSession({
+                sessionId: input.conversation.conversationId,
+                targetKind: input.targetKind,
+                targetSessionKey: input.targetSessionKey,
+                metadata: input.metadata,
+            });
+            return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        listBySession: (targetSessionKey) => manager
+            .listBySessionKey(targetSessionKey)
+            .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "xiaoyi-channel") {
+                return null;
+            }
+            const found = manager.getBySessionId(ref.conversationId);
+            return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        touch: (bindingId, at) => {
+            const sessionId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId,
+            });
+            if (sessionId) {
+                manager.touchSession(sessionId, at);
+            }
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                return manager
+                    .unbindBySessionKey(input.targetSessionKey.trim())
+                    .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
+            }
+            const sessionId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!sessionId) {
+                return [];
+            }
+            const removed = manager.unbindSession(sessionId);
+            return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
+        },
+    };
+    registerSessionBindingAdapter(sessionBindingAdapter);
+    getState().managersByAccountId.set(accountId, manager);
+    return manager;
+}
+/**
+ * Gets the thread binding manager for a given account ID.
+ */
+export function getXYThreadBindingManager(accountId) {
+    return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}
+/**
+ * Testing utilities for thread bindings.
+ */
+export const __testing = {
+    resetXYThreadBindingsForTests() {
+        for (const manager of getState().managersByAccountId.values()) {
+            manager.stop();
+        }
+        getState().managersByAccountId.clear();
+        getState().bindingsByAccountSession.clear();
+    },
+};

package/dist/src/tools/call-phone-tool.js

@@ -90,33 +90,17 @@ export const callPhoneTool = {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        // Check for error code in outputs
-                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
-                        if (code !== null && code !== 0) {
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            reject(new Error(`拨打电话失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
-                        // Return the outputs directly
-                        const result = {
-                            success: true,
-                            code: code,
-                            phoneNumber: params.phoneNumber,
-                            slotId: slotId,
-                            message: "电话拨打成功",
-                        };
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
                     }
                     else {
-                        const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
-                        reject(new Error(`拨打电话失败: ${errorDetail}`));
+                        reject(new Error(`拨打电话失败: ${event.status}`));
                     }
                 }
             };

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

@@ -6,7 +6,7 @@ const ALARM_SNOOZE_DURATION_VALUES = [5, 10, 15, 20, 25, 30];
 const ALARM_SNOOZE_TOTAL_VALUES = [0, 1, 3, 5, 10];
 const ALARM_RING_DURATION_VALUES = [1, 5, 10, 15, 20, 30];
 const DAYS_OF_WAKE_TYPE_VALUES = [0, 1, 2, 3, 4];
-const DAYS_OF_WEEK_VALUES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const DAYS_OF_WEEK_VALUES = ["Mon", "Tues", "Wed", "Thur", "Fri", "Sat", "Sun"];
 /**
  * XY create alarm tool - creates an alarm on user's device.
  * Requires alarmTime parameter. Other parameters are optional with sensible defaults.
@@ -27,7 +27,7 @@ export const createAlarmTool = {
 - alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）
 - alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30，默认5
 - daysOfWakeType: 闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0
-- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。
 
 注意事项：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
@@ -64,7 +64,7 @@ b. 使用该工具之前需获取当前真实时间
             daysOfWeek: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
             },
         },
         required: ["alarmTime"],
@@ -163,10 +163,6 @@ b. 使用该工具之前需获取当前真实时间
             if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
                 throw new Error("daysOfWeek array cannot be empty");
             }
-            // 验证数组长度必须为1
-            if (normalizedDaysOfWeek.length !== 1) {
-                throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
-            }
             // Validate each day
             for (const day of normalizedDaysOfWeek) {
                 if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {

package/dist/src/tools/device-tool-map.d.ts

@@ -0,0 +1,4 @@
+/** Known device type enum. */
+export declare const DEVICE_TYPES: readonly ["car", "2in1", "phone"];
+export type DeviceType = (typeof DEVICE_TYPES)[number];
+export declare function filterToolsByDevice(tools: any[], deviceType?: string): any[];

package/dist/src/tools/device-tool-map.js

@@ -0,0 +1,35 @@
+// Device type to tool name mapping.
+// Supports two modes:
+//   - allowlist: only listed tools are available (used for restrictive devices like car)
+//   - denylist: listed tools are blocked, everything else is available (used for permissive devices like pc)
+// Tools NOT listed in any device entry → available to all devices (no restriction).
+/** Known device type enum. */
+export const DEVICE_TYPES = ["car", "2in1", "phone"];
+const DEVICE_TOOL_POLICY = {
+    "2in1": {
+        allowlist: false,
+        tools: [
+            "xiaoyi_gui_agent",
+            "call_phone",
+            "send_message",
+            "search_message",
+            "search_contact",
+            "QueryCollection",
+            "AddCollection",
+            "DeleteCollection",
+        ],
+    },
+};
+export function filterToolsByDevice(tools, deviceType) {
+    if (!deviceType)
+        return tools;
+    const policy = DEVICE_TOOL_POLICY[deviceType];
+    if (!policy)
+        return tools; // unrecognized device → no filtering
+    if (policy.allowlist) {
+        return tools.filter((tool) => policy.tools.includes(tool.name));
+    }
+    else {
+        return tools.filter((tool) => !policy.tools.includes(tool.name));
+    }
+}

package/dist/src/tools/find-pc-devices-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY find PC devices tool - finds all PC devices associated with the user.
+ * Returns device IDs for use in subsequent file search operations.
+ */
+export declare const findPcDevicesTool: any;

package/dist/src/tools/find-pc-devices-tool.js

@@ -0,0 +1,98 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+/**
+ * XY find PC devices tool - finds all PC devices associated with the user.
+ * Returns device IDs for use in subsequent file search operations.
+ */
+export const findPcDevicesTool = {
+    name: "find_pc_devices",
+    label: "Find PC Devices",
+    description: `查找用户所有PC/电脑设备，获取设备ID列表。当用户说"帮我找一下PC/电脑上的xxx文件"、"帮我搜索电脑上的xxx"等涉及PC设备的请求时，先调用此工具获取设备ID，再进行后续操作。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    async execute(toolCallId, params) {
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Find PC devices tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build GetAllDevice command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    achieveType: "INTENT",
+                    actionResponse: true,
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    dimension: "",
+                    executeMode: "background",
+                    intentName: "GetAllDevice",
+                    intentParam: {},
+                    needUnlock: true,
+                    permissionId: [],
+                    timeOut: 5,
+                },
+                needUploadResult: true,
+                pageControlRelated: false,
+                responses: [{
+                        displayText: "",
+                        resultCode: "",
+                        ttsText: "",
+                    }],
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查找PC设备超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "GetAllDevice") {
+                    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(`查找PC设备失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            }).then(() => {
+            }).catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/image-reading-tool.js

@@ -87,8 +87,8 @@ async function processImageInput(imageInput, uploadService) {
 /**
  * Call image understanding API with streaming response
  */
-async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid) {
-    const apiUrl = "https://hag-drcn.op.dbankcloud.com/celia-claw/v1/sse-api/skill/execute";
+async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid, fileUploadUrl) {
+    const apiUrl = `${fileUploadUrl}/celia-claw/v1/sse-api/skill/execute`;
     const traceId = uuidv4();
     const headers = {
         "Content-Type": "application/json",
@@ -276,7 +276,7 @@ d. 返回图像理解的文本描述内容`,
                 downloadedFile = processedImage.localPath;
             }
             // Call image understanding API
-            const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid);
+            const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid, config.fileUploadUrl);
             // Clean up downloaded file if any
             if (downloadedFile) {
                 try {

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

@@ -6,7 +6,7 @@ const ALARM_SNOOZE_DURATION_VALUES = [5, 10, 15, 20, 25, 30];
 const ALARM_SNOOZE_TOTAL_VALUES = [0, 1, 3, 5, 10];
 const ALARM_RING_DURATION_VALUES = [1, 5, 10, 15, 20, 30];
 const DAYS_OF_WAKE_TYPE_VALUES = [0, 1, 2, 3, 4];
-const DAYS_OF_WEEK_VALUES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const DAYS_OF_WEEK_VALUES = ["Mon", "Tues", "Wed", "Thur", "Fri", "Sat", "Sun"];
 /**
  * XY modify alarm tool - modifies an existing alarm on user's device.
  * Requires entityId from search_alarm or create_alarm tool.
@@ -31,7 +31,7 @@ export const modifyAlarmTool = {
 - alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10
 - alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30
 - daysOfWakeType: 闹钟响铃类型，枚举值：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日
-- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。
 
 使用流程：
 1. 先调用 search_alarm 工具查询闹钟，获取 entityId，
@@ -79,7 +79,7 @@ export const modifyAlarmTool = {
             daysOfWeek: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
             },
         },
         required: ["entityId"],
@@ -199,10 +199,6 @@ export const modifyAlarmTool = {
                 if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
                     throw new Error("daysOfWeek array cannot be empty");
                 }
-                // 验证数组长度必须为1
-                if (normalizedDaysOfWeek.length !== 1) {
-                    throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
-                }
                 // Validate each day
                 for (const day of normalizedDaysOfWeek) {
                     if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {

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;

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

@@ -0,0 +1,170 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { XYFileUploadService } from "../file-upload.js";
+/**
+ * Duck-typed ToolInputError: openclaw 按 .name 字段匹配，不用 instanceof。
+ * 抛出此错误会让 openclaw 返回 HTTP 400 而非 500，
+ * LLM 会将其识别为参数错误而非瞬时故障，不会触发重试。
+ */
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 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 const saveFileToPhoneTool = {
+    name: "save_file_to_file_manager",
+    label: "Save File to Phone",
+    description: `将文件保存到手机文件管理器。
+  工具参数说明：
+  a. fileName：必填，string类型，文件名称。
+  b. url：必填，string类型，支持本地路径或者公网url路径。如果是本地路径，会先上传获取公网url再保存到手机。
+  c. suffix：必填，string类型，文件后缀，例如 ppt、doc、pdf 等。
+
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,不可以重试，直接返回错误。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            fileName: {
+                type: "string",
+                description: "必填，文件名称。",
+            },
+            url: {
+                type: "string",
+                description: "必填，支持本地路径或者公网url路径。如果是本地路径会先上传获取公网url。",
+            },
+            suffix: {
+                type: "string",
+                description: "必填，文件后缀，例如 ppt、doc、pdf 等。",
+            },
+        },
+        required: ["fileName", "url", "suffix"],
+    },
+    async execute(toolCallId, params) {
+        // Validate parameters
+        const { fileName, url, suffix } = params;
+        if (!url || typeof url !== "string") {
+            throw new ToolInputError("缺少必填参数: url");
+        }
+        if (!fileName || typeof fileName !== "string") {
+            throw new ToolInputError("缺少必填参数: fileName");
+        }
+        if (!suffix || typeof suffix !== "string") {
+            throw new ToolInputError("缺少必填参数: suffix");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. SaveFileToFileManager tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Determine the URL: if it's a local path, upload first to get public URL
+        let publicUrl = url;
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            // Local file path - upload to get public URL
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            publicUrl = await uploadService.uploadFileAndGetUrl(url);
+            if (!publicUrl) {
+                throw new Error("本地文件上传失败，无法获取公网URL");
+            }
+        }
+        // Build intentParam
+        const intentParam = {
+            fileName: fileName,
+            url: publicUrl,
+            suffix: suffix,
+        };
+        // Build SaveFileToFileManager command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SaveFileToFileManager",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    timeout: 55000,
+                    intentParam,
+                    permissionId: ["ohos.permission.WRITE_IMAGEVIDEO"],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("保存文件到手机超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "SaveFileToFileManager") {
+                    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}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};