@ynhcj/xiaoyi-channel 0.0.2 → 0.0.3-next

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

@@ -0,0 +1,259 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search calendar event tool - searches calendar events on user's device.
+ * Returns matching events based on time range and optional title filter.
+ *
+ * Time range guidelines:
+ * - For a specific day: use 00:00:00 to 23:59:59 of that day
+ * - For morning: 06:00:00 to 12:00:00
+ * - For afternoon: 12:00:00 to 18:00:00
+ * - For evening: 18:00:00 to 24:00:00
+ * - For a specific time: use ±1 hour range (e.g., for 3PM, use 14:00:00 to 16:00:00)
+ */
+export const searchCalendarTool = {
+    name: "search_calendar_event",
+    label: "Search Calendar Event",
+    description: `检索用户日历中的日程安排。根据时间范围和可选的日程标题进行检索。时间格式必须为：YYYYMMDD hhmmss（例如：20240115 143000）。
+
+时间范围说明：
+- 查询某一天的日程：使用该天的 00:00:00 到 23:59:59（例如：20240115 000000 到 20240115 235959）
+- 查询上午的日程：使用 06:00:00 到 12:00:00
+- 查询下午的日程：使用 12:00:00 到 18:00:00
+- 查询晚上的日程：使用 18:00:00 到 23:59:59
+- 查询某个时刻附近的日程：使用该时刻前后1小时的区间（例如：查询3点左右的日程，使用 14:00:00 到 16:00:00）
+
+注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "日程起始时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 143000 表示 2024年1月15日 14:30:00）",
+            },
+            endTime: {
+                type: "string",
+                description: "日程结束时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 173000 表示 2024年1月15日 17:30:00）",
+            },
+            title: {
+                type: "string",
+                description: "日程标题/类型（可选），用于过滤特定类型的日程",
+            },
+        },
+        required: ["startTime", "endTime"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.startTime || !params.endTime) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Missing required parameters`);
+            throw new Error("Missing required parameters: startTime and endTime are required");
+        }
+        // Convert time strings to millisecond timestamps
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime input: ${params.startTime}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime input: ${params.endTime}`);
+        // Parse YYYYMMDD hhmmss format
+        const parseTimeString = (timeStr) => {
+            // Remove any extra spaces and split
+            const cleaned = timeStr.trim().replace(/\s+/g, ' ');
+            const parts = cleaned.split(' ');
+            if (parts.length !== 2) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const datePart = parts[0]; // YYYYMMDD
+            const timePart = parts[1]; // hhmmss
+            if (datePart.length !== 8 || timePart.length !== 6) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const year = parseInt(datePart.substring(0, 4), 10);
+            const month = parseInt(datePart.substring(4, 6), 10) - 1; // Month is 0-indexed
+            const day = parseInt(datePart.substring(6, 8), 10);
+            const hours = parseInt(timePart.substring(0, 2), 10);
+            const minutes = parseInt(timePart.substring(2, 4), 10);
+            const seconds = parseInt(timePart.substring(4, 6), 10);
+            const date = new Date(year, month, day, hours, minutes, seconds);
+            return date.getTime();
+        };
+        // Helper function to convert timestamp to YYYYMMDD hhmmss format
+        const formatTimestamp = (timestamp) => {
+            const date = new Date(timestamp);
+            const year = date.getFullYear();
+            const month = String(date.getMonth() + 1).padStart(2, '0');
+            const day = String(date.getDate()).padStart(2, '0');
+            const hours = String(date.getHours()).padStart(2, '0');
+            const minutes = String(date.getMinutes()).padStart(2, '0');
+            const seconds = String(date.getSeconds()).padStart(2, '0');
+            return `${year}${month}${day} ${hours}${minutes}${seconds}`;
+        };
+        let startTimeMs;
+        let endTimeMs;
+        try {
+            startTimeMs = parseTimeString(params.startTime);
+            endTimeMs = parseTimeString(params.endTime);
+        }
+        catch (error) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Time parsing error:`, error);
+            throw new Error(`Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000). Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (isNaN(startTimeMs) || isNaN(endTimeMs)) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Invalid time format`);
+            throw new Error("Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000)");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Time conversion successful`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime timestamp: ${startTimeMs}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime timestamp: ${endTimeMs}`);
+        // Get session context
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search calendar tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchCalendarEvent command
+        logger.log(`[SEARCH_CALENDAR_TOOL] 📦 Building SearchCalendarEvent command...`);
+        // Build intentParam with timeInterval and optional title
+        const intentParam = {
+            timeInterval: [startTimeMs, endTimeMs],
+        };
+        if (params.title) {
+            intentParam.title = params.title;
+            logger.log(`[SEARCH_CALENDAR_TOOL]   - Including title filter: ${params.title}`);
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchCalendarEvent",
+                    bundleName: "com.huawei.hmos.calendardata",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar search response...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("检索日程超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchCalendarEvent") {
+                    logger.log(`[SEARCH_CALENDAR_TOOL] 🎯 SearchCalendarEvent event received`);
+                    logger.log(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events response received`);
+                        logger.log(`[SEARCH_CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code in outputs
+                        if (event.outputs.retErrCode && event.outputs.retErrCode !== "0") {
+                            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Device returned error`);
+                            logger.error(`[SEARCH_CALENDAR_TOOL]   - retErrCode: ${event.outputs.retErrCode}`);
+                            logger.error(`[SEARCH_CALENDAR_TOOL]   - errMsg: ${event.outputs.errMsg || "Unknown error"}`);
+                            reject(new Error(`检索日程失败: ${event.outputs.errMsg || "未知错误"} (错误代码: ${event.outputs.retErrCode})`));
+                            return;
+                        }
+                        // Return the result directly as requested
+                        const result = event.outputs.result;
+                        // Ensure result is not undefined
+                        if (result === undefined) {
+                            logger.warn(`[SEARCH_CALENDAR_TOOL] ⚠️ Result is undefined, returning empty result`);
+                        }
+                        // Convert dtStart and dtEnd from timestamps to YYYYMMDD hhmmss format
+                        if (result && result.items && Array.isArray(result.items)) {
+                            logger.log(`[SEARCH_CALENDAR_TOOL] 🔄 Converting timestamps to formatted dates...`);
+                            result.items = result.items.map((item) => {
+                                const formattedItem = { ...item };
+                                if (item.dtStart) {
+                                    formattedItem.dtStart = formatTimestamp(item.dtStart);
+                                    logger.log(`[SEARCH_CALENDAR_TOOL]   - dtStart: ${item.dtStart} -> ${formattedItem.dtStart}`);
+                                }
+                                if (item.dtEnd) {
+                                    formattedItem.dtEnd = formatTimestamp(item.dtEnd);
+                                    logger.log(`[SEARCH_CALENDAR_TOOL]   - dtEnd: ${item.dtEnd} -> ${formattedItem.dtEnd}`);
+                                }
+                                return formattedItem;
+                            });
+                        }
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: result !== undefined ? JSON.stringify(result) : "[]",
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Calendar event search failed`);
+                        logger.error(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`检索日程失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📤 Sending SearchCalendarEvent command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/search-contact-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY search contact tool - searches contacts on user's device.
+ * Returns matching contact information based on name.
+ */
+export declare const searchContactTool: any;

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

@@ -0,0 +1,168 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search contact tool - searches contacts on user's device.
+ * Returns matching contact information based on name.
+ */
+export const searchContactTool = {
+    name: "search_contact",
+    label: "Search Contact",
+    description: "搜索用户设备上的联系人信息。根据姓名在通讯录中检索联系人详细信息（包括姓名、电话号码、邮箱、组织、职位等）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "联系人姓名，用于在通讯录中检索联系人信息",
+            },
+        },
+        required: ["name"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_CONTACT_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_CONTACT_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.name) {
+            logger.error(`[SEARCH_CONTACT_TOOL] ❌ Missing required parameter: name`);
+            throw new Error("Missing required parameter: name is required");
+        }
+        // Get session context
+        logger.log(`[SEARCH_CONTACT_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_CONTACT_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_CONTACT_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search contact tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_CONTACT_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_CONTACT_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_CONTACT_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchContactLocal command
+        logger.log(`[SEARCH_CONTACT_TOOL] 📦 Building SearchContactLocal command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchContactLocal",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        name: params.name,
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_CONTACT_TOOL] ⏳ Setting up promise to wait for contact search response...`);
+        logger.log(`[SEARCH_CONTACT_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_CONTACT_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("搜索联系人超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[SEARCH_CONTACT_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchContactLocal") {
+                    logger.log(`[SEARCH_CONTACT_TOOL] 🎯 SearchContactLocal event received`);
+                    logger.log(`[SEARCH_CONTACT_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_CONTACT_TOOL] ✅ Contact search completed successfully`);
+                        logger.log(`[SEARCH_CONTACT_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code first
+                        if (event.outputs.retErrCode && event.outputs.retErrCode !== "0") {
+                            logger.error(`[SEARCH_CONTACT_TOOL] ❌ Search failed with error code: ${event.outputs.retErrCode}`);
+                            logger.error(`[SEARCH_CONTACT_TOOL]   - errMsg: ${event.outputs.errMsg}`);
+                            reject(new Error(`搜索联系人失败: ${event.outputs.errMsg || '未知错误'} (错误码: ${event.outputs.retErrCode})`));
+                            return;
+                        }
+                        // Get the result
+                        const result = event.outputs.result;
+                        // Check if result exists
+                        if (!result) {
+                            logger.warn(`[SEARCH_CONTACT_TOOL] ⚠️ No result found for name "${params.name}"`);
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({ items: [], message: "未找到匹配的联系人" }),
+                                    },
+                                ],
+                            });
+                            return;
+                        }
+                        logger.log(`[SEARCH_CONTACT_TOOL] 📊 Contacts found: ${result?.items?.length || 0} results for name "${params.name}"`);
+                        // Return the result with valid string content
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_CONTACT_TOOL] ❌ Contact search failed`);
+                        logger.error(`[SEARCH_CONTACT_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`搜索联系人失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[SEARCH_CONTACT_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_CONTACT_TOOL] 📤 Sending SearchContactLocal command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_CONTACT_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_CONTACT_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/search-file-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY search file tool - searches files on user's device file system.
+ * Returns matching files based on keyword search in file name or content.
+ */
+export declare const searchFileTool: any;

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

@@ -0,0 +1,185 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search file tool - searches files on user's device file system.
+ * Returns matching files based on keyword search in file name or content.
+ */
+export const searchFileTool = {
+    name: "search_file",
+    label: "Search File",
+    description: `搜索手机文件系统的文件。
+
+【重要】使用约束：此工具仅在用户显著说明要从手机搜索时才执行，例如：
+- "从我手机里面搜索xxxx"
+- "从手机文件系统找一下xxxx"
+- "在手机上查找文件xxxx"
+- "搜索手机里的文件"
+
+如果用户没有明确说明从手机搜索（如仅说"搜索文件"、"找一下xxxx"），应默认从 openclaw 本地的文件系统查询，不要调用此工具。
+
+功能说明：根据关键词搜索文件名称或内容，返回匹配的文件列表（包括文件名、路径、大小、修改时间等信息）。
+
+注意事项：操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。`,
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "搜索关键词，用于匹配文件名称、后缀名或文件内容",
+            },
+        },
+        required: ["query"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_FILE_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_FILE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_FILE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_FILE_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate query parameter
+        if (!params.query || typeof params.query !== "string" || params.query.trim() === "") {
+            logger.error(`[SEARCH_FILE_TOOL] ❌ Missing or invalid query parameter`);
+            throw new Error("Missing required parameter: query must be a non-empty string");
+        }
+        logger.log(`[SEARCH_FILE_TOOL] 🔍 Searching for files with keyword: ${params.query}`);
+        // Get session context
+        logger.log(`[SEARCH_FILE_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_FILE_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_FILE_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search file tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_FILE_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_FILE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_FILE_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_FILE_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_FILE_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_FILE_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchFile command
+        logger.log(`[SEARCH_FILE_TOOL] 📦 Building SearchFile command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchFile",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        query: params.query.trim(),
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        logger.log(`[SEARCH_FILE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_FILE_TOOL] ⏳ Setting up promise to wait for file search response...`);
+        logger.log(`[SEARCH_FILE_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_FILE_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("搜索文件超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[SEARCH_FILE_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchFile") {
+                    logger.log(`[SEARCH_FILE_TOOL] 🎯 SearchFile event received`);
+                    logger.log(`[SEARCH_FILE_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_FILE_TOOL] ✅ File search response received`);
+                        logger.log(`[SEARCH_FILE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code in outputs
+                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
+                        if (code !== null && code !== 0) {
+                            logger.error(`[SEARCH_FILE_TOOL] ❌ Device returned error`);
+                            logger.error(`[SEARCH_FILE_TOOL]   - code: ${code}`);
+                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
+                            logger.error(`[SEARCH_FILE_TOOL]   - errorMsg: ${errorMsg}`);
+                            reject(new Error(`搜索文件失败: ${errorMsg} (错误代码: ${code})`));
+                            return;
+                        }
+                        // Extract result.items with safe checks
+                        const result = event.outputs.result;
+                        let items = [];
+                        if (result && typeof result === "object" && Array.isArray(result.items)) {
+                            items = result.items;
+                            logger.log(`[SEARCH_FILE_TOOL] 📋 Found ${items.length} file(s)`);
+                        }
+                        else {
+                            logger.warn(`[SEARCH_FILE_TOOL] ⚠️ No items found in result or result is invalid`);
+                            logger.warn(`[SEARCH_FILE_TOOL]   - result:`, JSON.stringify(result || {}));
+                        }
+                        // Return items array as JSON string
+                        logger.log(`[SEARCH_FILE_TOOL] 🎉 File search completed successfully`);
+                        logger.log(`[SEARCH_FILE_TOOL]   - keyword: ${params.query}`);
+                        logger.log(`[SEARCH_FILE_TOOL]   - result count: ${items.length}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(items),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_FILE_TOOL] ❌ File search failed`);
+                        logger.error(`[SEARCH_FILE_TOOL]   - status: ${event.status}`);
+                        logger.error(`[SEARCH_FILE_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
+                        const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
+                        reject(new Error(`搜索文件失败: ${errorDetail}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[SEARCH_FILE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_FILE_TOOL] 📤 Sending SearchFile command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_FILE_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_FILE_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/search-message-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY search message tool - searches SMS messages on user's device.
+ * Returns matching messages based on content keyword search.
+ */
+export declare const searchMessageTool: any;