@ynhcj/xiaoyi-channel 0.0.27-beta → 0.0.29-beta

package/dist/src/channel.js

@@ -21,6 +21,7 @@ import { searchAlarmTool } from "./tools/search-alarm-tool.js";
 import { modifyAlarmTool } from "./tools/modify-alarm-tool.js";
 import { deleteAlarmTool } from "./tools/delete-alarm-tool.js";
 import { sendMessageTool } from "./tools/send-message-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -60,7 +61,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendMessageTool], // searchContactTool 已暂时禁用
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendMessageTool, sendFileToUserTool], // searchContactTool 已暂时禁用
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

package/dist/src/outbound.js

@@ -1,7 +1,6 @@
 import { resolveXYConfig } from "./config.js";
-import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
-import { getLatestSessionContext } from "./tools/session-manager.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -65,8 +64,8 @@ export const xyOutbound = {
         // If the target doesn't contain "::", try to enhance it with taskId from session context
         if (!trimmedTo.includes("::")) {
             console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
-            // Try to get the latest session context
-            const sessionContext = getLatestSessionContext();
+            // Try to get the current session context
+            const sessionContext = getCurrentSessionContext();
             if (sessionContext && sessionContext.sessionId === trimmedTo) {
                 const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
                 console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
@@ -130,81 +129,94 @@ export const xyOutbound = {
             mediaUrl,
             mediaLocalRoots,
         });
-        // Parse to: "sessionId::taskId"
-        const parts = to.split("::");
-        if (parts.length !== 2) {
-            throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
-        }
-        const [sessionId, taskId] = parts;
-        // Resolve configuration
-        const config = resolveXYConfig(cfg);
-        // Create upload service
-        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-        // Validate mediaUrl
-        if (!mediaUrl) {
-            throw new Error("mediaUrl is required for sendMedia");
-        }
-        // Upload file
-        const fileId = await uploadService.uploadFile(mediaUrl);
-        // Check if fileId is empty
-        if (!fileId) {
-            console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
-            return {
-                channel: "xiaoyi-channel",
-                messageId: "",
-                chatId: to,
-            };
-        }
-        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
-            fileId,
-            sessionId,
-            taskId,
-        });
-        // Get filename and mime type from mediaUrl
-        // mediaUrl may be a local file path or URL
-        const fileName = mediaUrl.split("/").pop() || "unknown";
-        const mimeType = getMimeTypeFromFilename(fileName);
-        // Build agent_response message
-        const agentResponse = {
-            msgType: "agent_response",
-            agentId: config.agentId,
-            sessionId: sessionId,
-            taskId: taskId,
-            msgDetail: JSON.stringify({
-                jsonrpc: "2.0",
-                id: taskId,
-                result: {
-                    kind: "artifact-update",
-                    append: true,
-                    lastChunk: false,
-                    final: false,
-                    artifact: {
-                        artifactId: taskId,
-                        parts: [
-                            {
-                                kind: "file",
-                                file: {
-                                    name: fileName,
-                                    mimeType: mimeType,
-                                    fileId: fileId,
-                                },
-                            },
-                        ],
-                    },
-                },
-                error: { code: 0 },
-            }),
-        };
-        // Get WebSocket manager and send message
-        const { getXYWebSocketManager } = await import("./client.js");
-        const wsManager = getXYWebSocketManager(config);
-        await wsManager.sendMessage(sessionId, agentResponse);
-        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
-        // Return message info
+        // All sendMedia processing logic has been disabled
+        // Use send_file_to_user tool instead for file transfers to user device
+        console.log(`[xyOutbound.sendMedia] Processing disabled, use send_file_to_user tool`);
+        // Return empty message info
         return {
             channel: "xiaoyi-channel",
-            messageId: fileId,
+            messageId: "",
             chatId: to,
         };
+        // // Parse to: "sessionId::taskId"
+        // const parts = to.split("::");
+        // if (parts.length !== 2) {
+        //   throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
+        // }
+        // const [sessionId, taskId] = parts;
+        // // Resolve configuration
+        // const config = resolveXYConfig(cfg);
+        // // Create upload service
+        // const uploadService = new XYFileUploadService(
+        //   config.fileUploadUrl,
+        //   config.apiKey,
+        //   config.uid
+        // );
+        // // Validate mediaUrl
+        // if (!mediaUrl) {
+        //   throw new Error("mediaUrl is required for sendMedia");
+        // }
+        // // Upload file
+        // const fileId = await uploadService.uploadFile(mediaUrl);
+        // // Check if fileId is empty
+        // if (!fileId) {
+        //   console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
+        //   return {
+        //     channel: "xiaoyi-channel",
+        //     messageId: "",
+        //     chatId: to,
+        //   };
+        // }
+        // console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+        //   fileId,
+        //   sessionId,
+        //   taskId,
+        // });
+        // // Get filename and mime type from mediaUrl
+        // // mediaUrl may be a local file path or URL
+        // const fileName = mediaUrl.split("/").pop() || "unknown";
+        // const mimeType = getMimeTypeFromFilename(fileName);
+        // // Build agent_response message
+        // const agentResponse: OutboundWebSocketMessage = {
+        //   msgType: "agent_response",
+        //   agentId: config.agentId,
+        //   sessionId: sessionId,
+        //   taskId: taskId,
+        //   msgDetail: JSON.stringify({
+        //     jsonrpc: "2.0",
+        //     id: taskId,
+        //     result: {
+        //       kind: "artifact-update",
+        //       append: true,
+        //       lastChunk: false,
+        //       final: false,
+        //       artifact: {
+        //         artifactId: taskId,
+        //         parts: [
+        //           {
+        //             kind: "file",
+        //             file: {
+        //               name: fileName,
+        //               mimeType: mimeType,
+        //               fileId: fileId,
+        //             },
+        //           },
+        //         ],
+        //       },
+        //     },
+        //     error: { code: 0 },
+        //   }),
+        // };
+        // // Get WebSocket manager and send message
+        // const { getXYWebSocketManager } = await import("./client.js");
+        // const wsManager = getXYWebSocketManager(config);
+        // await wsManager.sendMessage(sessionId, agentResponse);
+        // console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        // // Return message info
+        // return {
+        //   channel: "xiaoyi-channel",
+        //   messageId: fileId,
+        //   chatId: to,
+        // };
     },
 };

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

@@ -28,7 +28,7 @@ export const createAlarmTool = {
 - alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）
 - alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30，默认20
 - daysOfWakeType: 闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0
-- daysOfWeek: 自定义响铃星期，当daysOfWakeType=3时需要，数组，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
 
 注意事项：操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。`,
     parameters: {
@@ -52,18 +52,16 @@ export const createAlarmTool = {
             },
             alarmRingDuration: {
                 type: "number",
-                description: "响铃时长（分钟），枚举值：1,5,10,15,20,30，默认20",
+                description: "响铃时长（分钟），枚举值：1,5,10,15,20,30，默认5",
             },
             daysOfWakeType: {
                 type: "number",
                 description: "闹钟响铃类型：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日，默认0",
             },
             daysOfWeek: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "自定义响铃星期（当daysOfWakeType=3时需要），枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun",
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
             },
         },
         required: ["alarmTime"],
@@ -151,26 +149,68 @@ export const createAlarmTool = {
         // daysOfWeek - only required when daysOfWakeType is 3
         let daysOfWeek = [];
         if (daysOfWakeType === 3) {
-            if (!params.daysOfWeek || !Array.isArray(params.daysOfWeek)) {
+            if (!params.daysOfWeek) {
                 logger.error(`[CREATE_ALARM_TOOL] ❌ Missing daysOfWeek when daysOfWakeType=3`);
                 throw new Error("daysOfWeek is required when daysOfWakeType is 3 (custom)");
             }
-            if (!Array.isArray(params.daysOfWeek)) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid daysOfWeek type`);
-                throw new Error("daysOfWeek must be an array");
+            // ===== 参数规范化：兼容数组和 JSON 字符串 =====
+            let normalizedDaysOfWeek = null;
+            // 情况1: 已经是数组
+            if (Array.isArray(params.daysOfWeek)) {
+                logger.log(`[CREATE_ALARM_TOOL] ✅ daysOfWeek is already an array`);
+                normalizedDaysOfWeek = params.daysOfWeek;
+            }
+            // 情况2: 是字符串，尝试解析为 JSON 数组
+            else if (typeof params.daysOfWeek === 'string') {
+                logger.log(`[CREATE_ALARM_TOOL] 🔄 daysOfWeek is a string, attempting to parse as JSON...`);
+                try {
+                    const parsed = JSON.parse(params.daysOfWeek);
+                    if (Array.isArray(parsed)) {
+                        logger.log(`[CREATE_ALARM_TOOL] ✅ Successfully parsed JSON string to array`);
+                        normalizedDaysOfWeek = parsed;
+                    }
+                    else {
+                        logger.error(`[CREATE_ALARM_TOOL] ❌ Parsed JSON is not an array:`, typeof parsed);
+                        throw new Error("daysOfWeek must be an array or a JSON string representing an array");
+                    }
+                }
+                catch (parseError) {
+                    logger.error(`[CREATE_ALARM_TOOL] ❌ Failed to parse daysOfWeek as JSON:`, parseError);
+                    throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                }
+            }
+            // 情况3: 其他类型，报错
+            else {
+                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid daysOfWeek type:`, typeof params.daysOfWeek);
+                throw new Error(`daysOfWeek must be an array or a JSON string, got ${typeof params.daysOfWeek}`);
+            }
+            // 验证数组非空
+            if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
+                logger.error(`[CREATE_ALARM_TOOL] ❌ daysOfWeek array is empty`);
+                throw new Error("daysOfWeek array cannot be empty");
+            }
+            // 验证数组长度必须为1
+            if (normalizedDaysOfWeek.length !== 1) {
+                logger.error(`[CREATE_ALARM_TOOL] ❌ daysOfWeek array length must be 1, got ${normalizedDaysOfWeek.length}`);
+                throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
             }
             // Validate each day
-            for (const day of params.daysOfWeek) {
+            for (const day of normalizedDaysOfWeek) {
                 if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
                     logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid day value: ${day}`);
                     throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
                 }
             }
-            daysOfWeek = params.daysOfWeek;
+            daysOfWeek = normalizedDaysOfWeek;
             logger.log(`[CREATE_ALARM_TOOL]   - daysOfWeek: ${daysOfWeek.join(", ")}`);
         }
-        else if (params.daysOfWeek && params.daysOfWeek.length > 0) {
-            logger.warn(`[CREATE_ALARM_TOOL] ⚠️ daysOfWeek is ignored when daysOfWakeType is not 3`);
+        else {
+            // daysOfWakeType is not 3, daysOfWeek should not be provided
+            if (params.daysOfWeek) {
+                logger.warn(`[CREATE_ALARM_TOOL] ⚠️ daysOfWeek parameter is ignored when daysOfWakeType is not 3 (current: ${daysOfWakeType}). Please remove daysOfWeek parameter.`);
+            }
+            // Explicitly set to empty array
+            daysOfWeek = [];
         }
         // Get session context
         logger.log(`[CREATE_ALARM_TOOL] 🔍 Attempting to get session context...`);
@@ -191,6 +231,24 @@ export const createAlarmTool = {
         logger.log(`[CREATE_ALARM_TOOL] ✅ WebSocket manager obtained`);
         // Build CreateAlarm command
         logger.log(`[CREATE_ALARM_TOOL] 📦 Building CreateAlarm command...`);
+        // Build intentParam - only include daysOfWeek when daysOfWakeType is 3
+        const intentParam = {
+            entityName: "Alarm",
+            alarmTime: alarmTimeMs,
+            alarmTitle: alarmTitle,
+            alarmSnoozeDuration: alarmSnoozeDuration,
+            alarmSnoozeTotal: alarmSnoozeTotal,
+            alarmRingDuration: alarmRingDuration,
+            daysOfWakeType: daysOfWakeType,
+        };
+        // Only include daysOfWeek when daysOfWakeType is 3
+        if (daysOfWakeType === 3 && daysOfWeek.length > 0) {
+            intentParam.daysOfWeek = daysOfWeek;
+            logger.log(`[CREATE_ALARM_TOOL]   - Including daysOfWeek in intentParam: ${daysOfWeek.join(", ")}`);
+        }
+        else {
+            logger.log(`[CREATE_ALARM_TOOL]   - Excluding daysOfWeek from intentParam (daysOfWakeType=${daysOfWakeType})`);
+        }
         const command = {
             header: {
                 namespace: "Common",
@@ -206,16 +264,7 @@ export const createAlarmTool = {
                     actionResponse: true,
                     appType: "OHOS_APP",
                     timeOut: 5,
-                    intentParam: {
-                        entityName: "Alarm",
-                        alarmTime: alarmTimeMs,
-                        alarmTitle: alarmTitle,
-                        alarmSnoozeDuration: alarmSnoozeDuration,
-                        alarmSnoozeTotal: alarmSnoozeTotal,
-                        alarmRingDuration: alarmRingDuration,
-                        daysOfWakeType: daysOfWakeType,
-                        daysOfWeek: daysOfWeek,
-                    },
+                    intentParam: intentParam,
                     permissionId: [],
                     achieveType: "INTENT",
                 },

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

@@ -32,7 +32,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时需要），数组，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
 
 使用流程：
 1. 先调用 search_alarm 工具查询闹钟，获取 entityId
@@ -75,11 +75,9 @@ export const modifyAlarmTool = {
                 description: "闹钟响铃类型：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日",
             },
             daysOfWeek: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "自定义响铃星期（当daysOfWakeType=3时需要），枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun",
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
             },
         },
         required: ["entityId"],
@@ -177,7 +175,6 @@ export const modifyAlarmTool = {
             logger.log(`[MODIFY_ALARM_TOOL]   - alarmRingDuration: ${params.alarmRingDuration}`);
         }
         // Add daysOfWakeType if provided
-        let currentDaysOfWakeType = null;
         if (params.daysOfWakeType !== undefined && params.daysOfWakeType !== null) {
             if (typeof params.daysOfWakeType !== "number") {
                 logger.error(`[MODIFY_ALARM_TOOL] ❌ Invalid daysOfWakeType type`);
@@ -188,24 +185,68 @@ export const modifyAlarmTool = {
                 throw new Error(`daysOfWakeType must be one of: ${DAYS_OF_WAKE_TYPE_VALUES.join(", ")}`);
             }
             intentParam.daysOfWakeType = params.daysOfWakeType;
-            currentDaysOfWakeType = params.daysOfWakeType;
             logger.log(`[MODIFY_ALARM_TOOL]   - daysOfWakeType: ${params.daysOfWakeType}`);
         }
-        // Add daysOfWeek if provided
+        // Add daysOfWeek if provided - only valid when daysOfWakeType is 3
         if (params.daysOfWeek !== undefined && params.daysOfWeek !== null) {
-            if (!Array.isArray(params.daysOfWeek)) {
-                logger.error(`[MODIFY_ALARM_TOOL] ❌ Invalid daysOfWeek type`);
-                throw new Error("daysOfWeek must be an array");
+            // Check if daysOfWakeType is 3 or will be set to 3
+            const targetDaysOfWakeType = params.daysOfWakeType !== undefined ? params.daysOfWakeType : null;
+            if (targetDaysOfWakeType !== null && targetDaysOfWakeType !== 3) {
+                logger.warn(`[MODIFY_ALARM_TOOL] ⚠️ daysOfWeek parameter is ignored when daysOfWakeType is not 3 (current: ${targetDaysOfWakeType}). Please remove daysOfWeek parameter.`);
+                // Skip processing daysOfWeek when daysOfWakeType is not 3
             }
-            // Validate each day
-            for (const day of params.daysOfWeek) {
-                if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
-                    logger.error(`[MODIFY_ALARM_TOOL] ❌ Invalid day value: ${day}`);
-                    throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
+            else {
+                // ===== 参数规范化：兼容数组和 JSON 字符串 =====
+                let normalizedDaysOfWeek = null;
+                // 情况1: 已经是数组
+                if (Array.isArray(params.daysOfWeek)) {
+                    logger.log(`[MODIFY_ALARM_TOOL] ✅ daysOfWeek is already an array`);
+                    normalizedDaysOfWeek = params.daysOfWeek;
+                }
+                // 情况2: 是字符串，尝试解析为 JSON 数组
+                else if (typeof params.daysOfWeek === 'string') {
+                    logger.log(`[MODIFY_ALARM_TOOL] 🔄 daysOfWeek is a string, attempting to parse as JSON...`);
+                    try {
+                        const parsed = JSON.parse(params.daysOfWeek);
+                        if (Array.isArray(parsed)) {
+                            logger.log(`[MODIFY_ALARM_TOOL] ✅ Successfully parsed JSON string to array`);
+                            normalizedDaysOfWeek = parsed;
+                        }
+                        else {
+                            logger.error(`[MODIFY_ALARM_TOOL] ❌ Parsed JSON is not an array:`, typeof parsed);
+                            throw new Error("daysOfWeek must be an array or a JSON string representing an array");
+                        }
+                    }
+                    catch (parseError) {
+                        logger.error(`[MODIFY_ALARM_TOOL] ❌ Failed to parse daysOfWeek as JSON:`, parseError);
+                        throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    }
+                }
+                // 情况3: 其他类型，报错
+                else {
+                    logger.error(`[MODIFY_ALARM_TOOL] ❌ Invalid daysOfWeek type:`, typeof params.daysOfWeek);
+                    throw new Error(`daysOfWeek must be an array or a JSON string, got ${typeof params.daysOfWeek}`);
+                }
+                // 验证数组非空
+                if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
+                    logger.error(`[MODIFY_ALARM_TOOL] ❌ daysOfWeek array is empty`);
+                    throw new Error("daysOfWeek array cannot be empty");
+                }
+                // 验证数组长度必须为1
+                if (normalizedDaysOfWeek.length !== 1) {
+                    logger.error(`[MODIFY_ALARM_TOOL] ❌ daysOfWeek array length must be 1, got ${normalizedDaysOfWeek.length}`);
+                    throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
+                }
+                // Validate each day
+                for (const day of normalizedDaysOfWeek) {
+                    if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
+                        logger.error(`[MODIFY_ALARM_TOOL] ❌ Invalid day value: ${day}`);
+                        throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
+                    }
                 }
+                intentParam.daysOfWeek = normalizedDaysOfWeek;
+                logger.log(`[MODIFY_ALARM_TOOL]   - daysOfWeek: ${normalizedDaysOfWeek.join(", ")}`);
             }
-            intentParam.daysOfWeek = params.daysOfWeek;
-            logger.log(`[MODIFY_ALARM_TOOL]   - daysOfWeek: ${params.daysOfWeek.join(", ")}`);
         }
         // Get session context
         logger.log(`[MODIFY_ALARM_TOOL] 🔍 Attempting to get session context...`);

package/dist/src/tools/search-file-tool.js

@@ -9,7 +9,19 @@ import { logger } from "../utils/logger.js";
 export const searchFileTool = {
     name: "search_file",
     label: "Search File",
-    description: "搜索手机文件系统的文件。根据关键词搜索文件名称或内容，返回匹配的文件列表（包括文件名、路径、大小、修改时间等信息）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: `搜索手机文件系统的文件。
+
+【重要】使用约束：此工具仅在用户显著说明要从手机搜索时才执行，例如：
+- "从我手机里面搜索xxxx"
+- "从手机文件系统找一下xxxx"
+- "在手机上查找文件xxxx"
+- "搜索手机里的文件"
+
+如果用户没有明确说明从手机搜索（如仅说"搜索文件"、"找一下xxxx"），应默认从 openclaw 本地的文件系统查询，不要调用此工具。
+
+功能说明：根据关键词搜索文件名称或内容，返回匹配的文件列表（包括文件名、路径、大小、修改时间等信息）。
+
+注意事项：操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。`,
     parameters: {
         type: "object",
         properties: {

package/dist/src/tools/send-file-to-user-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY send file to user tool - sends local files or remote files to user's device.
+ * Supports both local file paths and remote URLs.
+ */
+export declare const sendFileToUserTool: any;

package/dist/src/tools/send-file-to-user-tool.js

@@ -0,0 +1,318 @@
+import { getXYWebSocketManager } from "../client.js";
+import { XYFileUploadService } from "../file-upload.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+import fetch from "node-fetch";
+import fs from "fs/promises";
+import path from "path";
+/**
+ * File extension to MIME type mapping
+ */
+const FILE_TYPE_TO_MIME_TYPE = {
+    txt: "text/plain",
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+};
+/**
+ * Get MIME type from file extension
+ */
+function getMimeTypeFromFilename(filename) {
+    const extension = filename.split(".").pop()?.toLowerCase();
+    if (extension && FILE_TYPE_TO_MIME_TYPE[extension]) {
+        return FILE_TYPE_TO_MIME_TYPE[extension];
+    }
+    return "text/plain";
+}
+/**
+ * Normalize parameter to array (supports both array and JSON string)
+ */
+function normalizeToArray(param) {
+    if (Array.isArray(param)) {
+        return param;
+    }
+    if (typeof param === 'string') {
+        try {
+            const parsed = JSON.parse(param);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            throw new Error("Parameter must be an array or a JSON string representing an array");
+        }
+        catch (parseError) {
+            throw new Error(`Parameter must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+        }
+    }
+    throw new Error(`Parameter must be an array or a JSON string, got ${typeof param}`);
+}
+/**
+ * Download remote file to local temp directory
+ */
+async function downloadRemoteFile(url) {
+    logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading remote file: ${url}`);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Get filename from URL or use default
+        let filename = url.split("/").pop() || "downloaded_file";
+        // Remove query parameters if present
+        filename = filename.split("?")[0];
+        // Ensure temp directory exists
+        const tempDir = "/tmp/xy_channel";
+        await fs.mkdir(tempDir, { recursive: true });
+        // Generate unique filename to avoid conflicts
+        const timestamp = Date.now();
+        const ext = path.extname(filename);
+        const baseName = path.basename(filename, ext);
+        const uniqueFilename = `${baseName}_${timestamp}${ext}`;
+        const localPath = path.join(tempDir, uniqueFilename);
+        // Save file to local temp directory
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await fs.writeFile(localPath, buffer);
+        logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ File downloaded to: ${localPath}`);
+        return localPath;
+    }
+    catch (error) {
+        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to download file from ${url}:`, error);
+        throw new Error(`Failed to download remote file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * XY send file to user tool - sends local files or remote files to user's device.
+ * Supports both local file paths and remote URLs.
+ */
+export const sendFileToUserTool = {
+    name: "send_file_to_user",
+    label: "Send File to User",
+    description: `工具能力描述：帮助用户把本地的文件或者公网地址的文件传到手机。
+
+工具参数说明：
+a. fileLocalUrls：本地文件路径数组，包含用户需要回传的文件在本地的地址
+b. fileRemoteUrls：公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送）
+c. fileLocalUrls 与 fileRemoteUrls 任意一个不为空即可，两者都提供时都会处理
+
+注意事项：
+a. 支持传入数组或 JSON 字符串格式
+b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如果超时或失败，最多重试一次`,
+    parameters: {
+        type: "object",
+        properties: {
+            fileLocalUrls: {
+                description: "本地文件路径数组，包含用户需要回传的文件在本地的地址",
+            },
+            fileRemoteUrls: {
+                description: "公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送）",
+            },
+        },
+    },
+    async execute(toolCallId, params) {
+        // Set timeout for the entire operation (2 minutes)
+        const TOOL_TIMEOUT = 120000; // 2 minutes in milliseconds
+        let timeoutHandle = null;
+        // Create a timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                reject(new Error("操作超时（2分钟）"));
+            }, TOOL_TIMEOUT);
+        });
+        // Create the main execution promise
+        const executionPromise = (async () => {
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 🚀 Starting execution`);
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - toolCallId: ${toolCallId}`);
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - params (raw):`, JSON.stringify(params));
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - timestamp: ${new Date().toISOString()}`);
+            // Validate that at least one parameter is provided
+            if (!params.fileLocalUrls && !params.fileRemoteUrls) {
+                logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Missing both fileLocalUrls and fileRemoteUrls parameters`);
+                throw new Error("At least one of fileLocalUrls or fileRemoteUrls must be provided");
+            }
+            // Normalize fileLocalUrls parameter
+            let fileLocalUrls = [];
+            if (params.fileLocalUrls) {
+                logger.log(`[SEND_FILE_TO_USER_TOOL] 🔄 Normalizing fileLocalUrls parameter...`);
+                fileLocalUrls = normalizeToArray(params.fileLocalUrls);
+                if (fileLocalUrls.length === 0) {
+                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ fileLocalUrls array is empty`);
+                    throw new Error("fileLocalUrls array cannot be empty");
+                }
+                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Normalized fileLocalUrls:`, JSON.stringify(fileLocalUrls));
+            }
+            // Normalize fileRemoteUrls parameter
+            let fileRemoteUrls = [];
+            if (params.fileRemoteUrls) {
+                logger.log(`[SEND_FILE_TO_USER_TOOL] 🔄 Normalizing fileRemoteUrls parameter...`);
+                fileRemoteUrls = normalizeToArray(params.fileRemoteUrls);
+                if (fileRemoteUrls.length === 0) {
+                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ fileRemoteUrls array is empty`);
+                    throw new Error("fileRemoteUrls array cannot be empty");
+                }
+                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Normalized fileRemoteUrls:`, JSON.stringify(fileRemoteUrls));
+            }
+            // Get session context
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 🔍 Attempting to get session context...`);
+            const sessionContext = getCurrentSessionContext();
+            if (!sessionContext) {
+                logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ FAILED: No active session found!`);
+                logger.error(`[SEND_FILE_TO_USER_TOOL]   - toolCallId: ${toolCallId}`);
+                throw new Error("No active XY session found. Send file to user tool can only be used during an active conversation.");
+            }
+            logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Session context found`);
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - taskId: ${sessionContext.taskId}`);
+            logger.log(`[SEND_FILE_TO_USER_TOOL]   - messageId: ${sessionContext.messageId}`);
+            const { config, sessionId, taskId, messageId } = sessionContext;
+            // Get WebSocket manager
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 🔌 Getting WebSocket manager...`);
+            const wsManager = getXYWebSocketManager(config);
+            logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ WebSocket manager obtained`);
+            // Create upload service
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            // Collect all local file paths to upload
+            const allLocalPaths = [...fileLocalUrls];
+            const downloadedFiles = [];
+            // Download remote files to local temp directory
+            if (fileRemoteUrls.length > 0) {
+                logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading ${fileRemoteUrls.length} remote files...`);
+                for (let i = 0; i < fileRemoteUrls.length; i++) {
+                    const remoteUrl = fileRemoteUrls[i];
+                    logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading remote file ${i + 1}/${fileRemoteUrls.length}: ${remoteUrl}`);
+                    try {
+                        const localPath = await downloadRemoteFile(remoteUrl);
+                        allLocalPaths.push(localPath);
+                        downloadedFiles.push(localPath);
+                    }
+                    catch (error) {
+                        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to download file ${i + 1}:`, error);
+                        throw new Error(`Failed to download remote file ${remoteUrl}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Downloaded ${downloadedFiles.length} remote files`);
+            }
+            // Upload all local files and get fileIds
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 📤 Uploading ${allLocalPaths.length} files...`);
+            const uploadedFiles = [];
+            for (let i = 0; i < allLocalPaths.length; i++) {
+                const localPath = allLocalPaths[i];
+                logger.log(`[SEND_FILE_TO_USER_TOOL] 📤 Uploading file ${i + 1}/${allLocalPaths.length}: ${localPath}`);
+                try {
+                    // Upload file using three-phase upload
+                    const fileId = await uploadService.uploadFile(localPath);
+                    if (!fileId) {
+                        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to upload file: ${localPath} (fileId is empty)`);
+                        throw new Error(`Failed to upload file: ${localPath}`);
+                    }
+                    // Get filename and mime type
+                    const fileName = localPath.split("/").pop() || "unknown";
+                    const mimeType = getMimeTypeFromFilename(fileName);
+                    uploadedFiles.push({ fileName, fileId, mimeType });
+                    logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ File uploaded successfully: ${fileName} -> ${fileId}`);
+                }
+                catch (error) {
+                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to upload file ${i + 1}:`, error);
+                    throw new Error(`Failed to upload file ${localPath}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            // Clean up downloaded files
+            if (downloadedFiles.length > 0) {
+                logger.log(`[SEND_FILE_TO_USER_TOOL] 🧹 Cleaning up ${downloadedFiles.length} downloaded files...`);
+                for (const downloadedFile of downloadedFiles) {
+                    try {
+                        await fs.unlink(downloadedFile);
+                        logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Cleaned up: ${downloadedFile}`);
+                    }
+                    catch (error) {
+                        logger.warn(`[SEND_FILE_TO_USER_TOOL] ⚠️ Failed to clean up file ${downloadedFile}:`, error);
+                    }
+                }
+            }
+            // Build and send agent_response messages for each file
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 📦 Building and sending agent_response messages...`);
+            const sentFiles = [];
+            for (const uploadedFile of uploadedFiles) {
+                const { fileName, fileId, mimeType } = uploadedFile;
+                const agentResponse = {
+                    msgType: "agent_response",
+                    agentId: config.agentId,
+                    sessionId: sessionId,
+                    taskId: taskId,
+                    msgDetail: JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: taskId,
+                        result: {
+                            kind: "artifact-update",
+                            append: true,
+                            lastChunk: false,
+                            final: false,
+                            artifact: {
+                                artifactId: taskId,
+                                parts: [
+                                    {
+                                        kind: "file",
+                                        file: {
+                                            name: fileName,
+                                            mimeType: mimeType,
+                                            fileId: fileId,
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        error: { code: 0 },
+                    }),
+                };
+                // Send WebSocket message
+                await wsManager.sendMessage(sessionId, agentResponse);
+                sentFiles.push({ fileName, fileId });
+                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Sent file to user: ${fileName} (fileId: ${fileId})`);
+            }
+            logger.log(`[SEND_FILE_TO_USER_TOOL] 🎉 Successfully sent ${sentFiles.length} files to user`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            sentFiles,
+                            count: sentFiles.length,
+                            message: `成功发送 ${sentFiles.length} 个文件到用户设备`
+                        }),
+                    },
+                ],
+            };
+        })();
+        // Race between execution and timeout
+        try {
+            const result = await Promise.race([executionPromise, timeoutPromise]);
+            // Clear timeout if execution completed
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            return result;
+        }
+        catch (error) {
+            // Clear timeout on error
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            throw error;
+        }
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.27-beta",
+  "version": "0.0.29-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",