@ynhcj/xiaoyi-channel 0.0.2 → 0.0.3-next

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

@@ -0,0 +1,173 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search message tool - searches SMS messages on user's device.
+ * Returns matching messages based on content keyword search.
+ */
+export const searchMessageTool = {
+    name: "search_message",
+    label: "Search Message",
+    description: "搜索手机短信。根据关键词搜索短信内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            content: {
+                type: "string",
+                description: "搜索关键词，用于在短信内容中进行匹配",
+            },
+        },
+        required: ["content"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_MESSAGE_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate content parameter
+        if (!params.content || typeof params.content !== "string" || params.content.trim() === "") {
+            logger.error(`[SEARCH_MESSAGE_TOOL] ❌ Missing or invalid content parameter`);
+            throw new Error("Missing required parameter: content must be a non-empty string");
+        }
+        logger.log(`[SEARCH_MESSAGE_TOOL] 🔍 Searching for messages with keyword: ${params.content}`);
+        // Get session context
+        logger.log(`[SEARCH_MESSAGE_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_MESSAGE_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search message tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_MESSAGE_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_MESSAGE_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_MESSAGE_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchMessage command
+        logger.log(`[SEARCH_MESSAGE_TOOL] 📦 Building SearchMessage command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchMessage",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        content: params.content.trim(),
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        logger.log(`[SEARCH_MESSAGE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_MESSAGE_TOOL] ⏳ Setting up promise to wait for message search response...`);
+        logger.log(`[SEARCH_MESSAGE_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_MESSAGE_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_MESSAGE_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchMessage") {
+                    logger.log(`[SEARCH_MESSAGE_TOOL] 🎯 SearchMessage event received`);
+                    logger.log(`[SEARCH_MESSAGE_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_MESSAGE_TOOL] ✅ Message search response received`);
+                        logger.log(`[SEARCH_MESSAGE_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_MESSAGE_TOOL] ❌ Device returned error`);
+                            logger.error(`[SEARCH_MESSAGE_TOOL]   - code: ${code}`);
+                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
+                            logger.error(`[SEARCH_MESSAGE_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_MESSAGE_TOOL] 📋 Found ${items.length} message(s)`);
+                        }
+                        else {
+                            logger.warn(`[SEARCH_MESSAGE_TOOL] ⚠️ No items found in result or result is invalid`);
+                            logger.warn(`[SEARCH_MESSAGE_TOOL]   - result:`, JSON.stringify(result || {}));
+                        }
+                        // Return items array as JSON string
+                        logger.log(`[SEARCH_MESSAGE_TOOL] 🎉 Message search completed successfully`);
+                        logger.log(`[SEARCH_MESSAGE_TOOL]   - keyword: ${params.content}`);
+                        logger.log(`[SEARCH_MESSAGE_TOOL]   - result count: ${items.length}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(items),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_MESSAGE_TOOL] ❌ Message search failed`);
+                        logger.error(`[SEARCH_MESSAGE_TOOL]   - status: ${event.status}`);
+                        logger.error(`[SEARCH_MESSAGE_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_MESSAGE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_MESSAGE_TOOL] 📤 Sending SearchMessage command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_MESSAGE_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_MESSAGE_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

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

@@ -0,0 +1,5 @@
+/**
+ * XY search note tool - searches notes on user's device.
+ * Returns matching notes based on query string.
+ */
+export declare const searchNoteTool: any;

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

@@ -0,0 +1,130 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search note tool - searches notes on user's device.
+ * Returns matching notes based on query string.
+ */
+export const searchNoteTool = {
+    name: "search_notes",
+    label: "Search Notes",
+    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "搜索关键词，用于在备忘录中检索相关内容",
+            },
+        },
+        required: ["query"],
+    },
+    async execute(toolCallId, params) {
+        logger.debug("Executing search note tool, toolCallId:", toolCallId);
+        // Validate parameters
+        if (!params.query) {
+            throw new Error("Missing required parameter: query is required");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Search note tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build SearchNote command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchNote",
+                    bundleName: "com.huawei.hmos.notepad",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        query: params.query,
+                    },
+                    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) => {
+                logger.debug("Received data event:", event);
+                if (event.intentName === "SearchNote") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        const { result, code } = event.outputs;
+                        const items = result?.items || [];
+                        logger.log(`Notes found: ${items.length} results for query "${params.query}"`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        query: params.query,
+                                        totalResults: items.length,
+                                        notes: items.map((item) => ({
+                                            entityId: item.entityId,
+                                            entityName: item.entityName,
+                                            title: item.title?.replace(/<\/?em>/g, ''), // Remove <em> tags
+                                            content: item.content,
+                                            createdDate: item.createdDate,
+                                            modifiedDate: item.modifiedDate,
+                                        })),
+                                        indexName: result?.indexName,
+                                        code,
+                                    }),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`搜索备忘录失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            }).catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/search-photo-gallery-tool.d.ts

@@ -0,0 +1,8 @@
+/**
+ * XY search photo gallery tool - searches photos in user's gallery.
+ * Returns local mediaUri strings that can be used with upload_photo tool.
+ *
+ * IMPORTANT: The returned mediaUris are LOCAL URIs that cannot be downloaded directly.
+ * To get publicly accessible URLs, use the upload_photo tool with these URIs.
+ */
+export declare const searchPhotoGalleryTool: any;

package/dist/src/tools/search-photo-gallery-tool.js

@@ -0,0 +1,184 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search photo gallery tool - searches photos in user's gallery.
+ * Returns local mediaUri strings that can be used with upload_photo tool.
+ *
+ * IMPORTANT: The returned mediaUris are LOCAL URIs that cannot be downloaded directly.
+ * To get publicly accessible URLs, use the upload_photo tool with these URIs.
+ */
+export const searchPhotoGalleryTool = {
+    name: "search_photo_gallery",
+    label: "Search Photo Gallery",
+    description: `插件功能描述：搜索用户手机图库中的照片
+  工具使用约束：如果用户说从手机图库中或者从相册中查询xx图片时调用此工具。
+  工具输入输出简介：
+  a. 根据图像描述语料检索匹配的照片,返回照片在手机本地的 mediaUri以及thumbnailUri。
+  b. 返回的 mediaUri以及thumbnailUri 是本地路径,无法直接下载或访问。如果需要下载、查看、使用或展示照片,请使用 upload_photo 工具将 mediaUri或者thumbnailUri 转换为可访问的公网 URL。
+  c. mediaUri代表手机相册中的图片原图路径，图片大小比较大，清晰度比较高
+  d. thumbnailUri代表手机相册中的图片缩略图路径，图片大小比较小，清晰度适中，建议在upload_photo 工具的入参中优先使用此路径，不容易引起上传超时等问题
+  
+  注意事项：
+  a. 只有当用户明确表达从手机相册搜索或者从图库搜索时才执行此工具，如果用户仅表达要搜索xxx图片，并没有说明搜索数据源，则不要贸然调用此插件，可以优先尝试websearch或者询问用户是否要从手机图库中搜索。
+  b. 操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "图像描述语料，用于检索匹配的照片（例如：'小狗的照片'、'带有键盘的图片'等）",
+            },
+        },
+        required: ["query"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.query) {
+            logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ Missing required parameter: query`);
+            throw new Error("Missing required parameter: query is required");
+        }
+        // Get session context
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_PHOTO_GALLERY_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search photo gallery tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ WebSocket manager obtained`);
+        // Search for photos
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📸 Searching for photos...`);
+        const items = await searchPhotos(wsManager, config, sessionId, taskId, messageId, params.query);
+        if (!items || items.length === 0) {
+            logger.warn(`[SEARCH_PHOTO_GALLERY_TOOL] ⚠️ No photos found for query: ${params.query}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            items: [],
+                            count: 0,
+                            message: "未找到匹配的照片"
+                        }),
+                    },
+                ],
+            };
+        }
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ Found ${items.length} photos`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - items:`, JSON.stringify(items));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        items,
+                        count: items.length,
+                        message: `找到 ${items.length} 张照片。注意：mediaUri 和 thumbnailUri 是本地路径，无法直接访问。如需下载或查看，请使用 upload_photo 工具。`
+                    }),
+                },
+            ],
+        };
+    },
+};
+/**
+ * Search for photos using query description
+ * Returns array of photo items with complete information
+ */
+async function searchPhotos(wsManager, config, sessionId, taskId, messageId, query) {
+    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📦 Building SearchPhotoVideo command...`);
+    const command = {
+        header: {
+            namespace: "Common",
+            name: "Action",
+        },
+        payload: {
+            cardParam: {},
+            executeParam: {
+                executeMode: "background",
+                intentName: "SearchPhotoVideo",
+                bundleName: "com.huawei.hmos.aidispatchservice",
+                needUnlock: true,
+                actionResponse: true,
+                appType: "OHOS_APP",
+                timeOut: 5,
+                intentParam: {
+                    query: query,
+                },
+                permissionId: [],
+                achieveType: "INTENT",
+            },
+            responses: [
+                {
+                    resultCode: "",
+                    displayText: "",
+                    ttsText: "",
+                },
+            ],
+            needUploadResult: true,
+            noHalfPage: false,
+            pageControlRelated: false,
+        },
+    };
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ⏰ Timeout: No response for SearchPhotoVideo within 60 seconds`);
+            wsManager.off("data-event", handler);
+            reject(new Error("搜索照片超时（60秒）"));
+        }, 60000);
+        const handler = (event) => {
+            logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📨 Received data event:`, JSON.stringify(event));
+            if (event.intentName === "SearchPhotoVideo") {
+                logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 🎯 SearchPhotoVideo event received`);
+                logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - status: ${event.status}`);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                if (event.status === "success" && event.outputs) {
+                    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ Photo search completed successfully`);
+                    const result = event.outputs.result;
+                    const items = result?.items || [];
+                    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📊 Found ${items.length} photo items`);
+                    resolve(items);
+                }
+                else {
+                    logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ Photo search failed`);
+                    logger.error(`[SEARCH_PHOTO_GALLERY_TOOL]   - status: ${event.status}`);
+                    reject(new Error(`搜索照片失败: ${event.status}`));
+                }
+            }
+        };
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📡 Registering data-event handler for SearchPhotoVideo`);
+        wsManager.on("data-event", handler);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📤 Sending SearchPhotoVideo command...`);
+        sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        })
+            .then(() => {
+            logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ SearchPhotoVideo command sent successfully`);
+        })
+            .catch((error) => {
+            logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ Failed to send SearchPhotoVideo command:`, error);
+            clearTimeout(timeout);
+            wsManager.off("data-event", handler);
+            reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * XY search photo tool - searches photos in user's gallery.
+ * Returns publicly accessible URLs of matching photos based on query description.
+ *
+ * This tool performs a two-step operation:
+ * 1. Search for photos using query description
+ * 2. Upload found photos to get publicly accessible URLs
+ */
+export declare const searchPhotoTool: any;