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

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.js

@@ -1,6 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { logger } from "../utils/logger.js";
 /**
  * XY search note tool - searches notes on user's device.
@@ -27,7 +27,7 @@ export const searchNoteTool = {
             throw new Error("Missing required parameter: query is required");
         }
         // Get session context
-        const sessionContext = getLatestSessionContext();
+        const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
             throw new Error("No active XY session found. Search note tool can only be used during an active conversation.");
         }

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

@@ -1,6 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { logger } from "../utils/logger.js";
 /**
  * XY search photo gallery tool - searches photos in user's gallery.
@@ -46,7 +46,7 @@ export const searchPhotoGalleryTool = {
         }
         // Get session context
         logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 🔍 Attempting to get session context...`);
-        const sessionContext = getLatestSessionContext();
+        const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
             logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ FAILED: No active session found!`);
             logger.error(`[SEARCH_PHOTO_GALLERY_TOOL]   - toolCallId: ${toolCallId}`);

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

@@ -0,0 +1,5 @@
+/**
+ * XY send message tool - sends SMS message on user's device.
+ * Requires phoneNumber (with +86 prefix) and content parameters.
+ */
+export declare const sendMessageTool: any;

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

@@ -0,0 +1,189 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY send message tool - sends SMS message on user's device.
+ * Requires phoneNumber (with +86 prefix) and content parameters.
+ */
+export const sendMessageTool = {
+    name: "send_message",
+    label: "Send Message",
+    description: "通过手机发送短信。需要提供接收方手机号码和短信内容。手机号码会自动添加+86前缀（如果没有的话）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            phoneNumber: {
+                type: "string",
+                description: "接收方手机号码（会自动添加+86前缀）",
+            },
+            content: {
+                type: "string",
+                description: "短信内容",
+            },
+        },
+        required: ["phoneNumber", "content"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEND_MESSAGE_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEND_MESSAGE_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate phoneNumber parameter
+        if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
+            logger.error(`[SEND_MESSAGE_TOOL] ❌ Missing or invalid phoneNumber parameter`);
+            throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
+        }
+        // Validate content parameter
+        if (!params.content || typeof params.content !== "string" || params.content.trim() === "") {
+            logger.error(`[SEND_MESSAGE_TOOL] ❌ Missing or invalid content parameter`);
+            throw new Error("Missing required parameter: content must be a non-empty string");
+        }
+        // Normalize phone number: add +86 prefix if not present
+        let phoneNumber = params.phoneNumber.trim();
+        if (!phoneNumber.startsWith("+86")) {
+            // Remove leading 0 if present (e.g., 086 -> 86)
+            if (phoneNumber.startsWith("0")) {
+                phoneNumber = phoneNumber.substring(1);
+            }
+            // Remove +86 or 86 prefix if already present to avoid duplication
+            if (phoneNumber.startsWith("86")) {
+                phoneNumber = phoneNumber.substring(2);
+            }
+            phoneNumber = `+86${phoneNumber}`;
+            logger.log(`[SEND_MESSAGE_TOOL] 📞 Normalized phone number: ${params.phoneNumber} -> ${phoneNumber}`);
+        }
+        logger.log(`[SEND_MESSAGE_TOOL] 📤 Preparing to send message`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - phoneNumber: ${phoneNumber}`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - content length: ${params.content.length} characters`);
+        // Get session context
+        logger.log(`[SEND_MESSAGE_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEND_MESSAGE_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEND_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Send message tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEND_MESSAGE_TOOL] ✅ Session context found`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEND_MESSAGE_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEND_MESSAGE_TOOL] ✅ WebSocket manager obtained`);
+        // Build SendShortMessage command
+        logger.log(`[SEND_MESSAGE_TOOL] 📦 Building SendShortMessage command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SendShortMessage",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        phoneNumber: phoneNumber,
+                        content: params.content.trim(),
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        logger.log(`[SEND_MESSAGE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEND_MESSAGE_TOOL] ⏳ Setting up promise to wait for send message response...`);
+        logger.log(`[SEND_MESSAGE_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEND_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(`[SEND_MESSAGE_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SendShortMessage") {
+                    logger.log(`[SEND_MESSAGE_TOOL] 🎯 SendShortMessage event received`);
+                    logger.log(`[SEND_MESSAGE_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEND_MESSAGE_TOOL] ✅ Send message response received`);
+                        logger.log(`[SEND_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(`[SEND_MESSAGE_TOOL] ❌ Device returned error`);
+                            logger.error(`[SEND_MESSAGE_TOOL]   - code: ${code}`);
+                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
+                            logger.error(`[SEND_MESSAGE_TOOL]   - errorMsg: ${errorMsg}`);
+                            reject(new Error(`发送短信失败: ${errorMsg} (错误代码: ${code})`));
+                            return;
+                        }
+                        // Extract result with safe checks
+                        const result = event.outputs.result || {};
+                        logger.log(`[SEND_MESSAGE_TOOL] 🎉 Message sent successfully`);
+                        logger.log(`[SEND_MESSAGE_TOOL]   - phoneNumber: ${phoneNumber}`);
+                        logger.log(`[SEND_MESSAGE_TOOL]   - result:`, JSON.stringify(result));
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEND_MESSAGE_TOOL] ❌ Send message failed`);
+                        logger.error(`[SEND_MESSAGE_TOOL]   - status: ${event.status}`);
+                        logger.error(`[SEND_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(`[SEND_MESSAGE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEND_MESSAGE_TOOL] 📤 Sending SendShortMessage command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEND_MESSAGE_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEND_MESSAGE_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/session-manager.d.ts

@@ -23,7 +23,19 @@ export declare function unregisterSession(sessionKey: string): void;
 export declare function getSessionContext(sessionKey: string): SessionContext | null;
 /**
  * Get the most recent session context.
+ * @deprecated Use getCurrentSessionContext() instead for thread-safe access.
  * This is a fallback for tools that don't have access to sessionKey.
  * Returns null if no sessions are active.
  */
 export declare function getLatestSessionContext(): SessionContext | null;
+/**
+ * Run a callback with a session context stored in AsyncLocalStorage.
+ * This ensures thread-safe context isolation for concurrent requests.
+ */
+export declare function runWithSessionContext<T>(context: SessionContext, callback: () => Promise<T>): Promise<T>;
+/**
+ * Get the current session context from AsyncLocalStorage.
+ * This is the recommended way to access session context in tools.
+ * Returns null if not running within a session context.
+ */
+export declare function getCurrentSessionContext(): SessionContext | null;

package/dist/src/tools/session-manager.js

@@ -1,7 +1,12 @@
+// Session manager for XY tool context
+// Stores active session contexts that tools can access
+import { AsyncLocalStorage } from "async_hooks";
 import { logger } from "../utils/logger.js";
 import { configManager } from "../utils/config-manager.js";
 // Map of sessionKey -> SessionContextWithRef
 const activeSessions = new Map();
+// AsyncLocalStorage for thread-safe session context isolation
+const asyncLocalStorage = new AsyncLocalStorage();
 /**
  * Register a session context for tool access.
  * Should be called when starting to process a message.
@@ -74,6 +79,7 @@ export function getSessionContext(sessionKey) {
 }
 /**
  * Get the most recent session context.
+ * @deprecated Use getCurrentSessionContext() instead for thread-safe access.
  * This is a fallback for tools that don't have access to sessionKey.
  * Returns null if no sessions are active.
  */
@@ -96,3 +102,30 @@ export function getLatestSessionContext() {
     const { refCount, ...latestSession } = latestSessionWithRef;
     return latestSession;
 }
+/**
+ * Run a callback with a session context stored in AsyncLocalStorage.
+ * This ensures thread-safe context isolation for concurrent requests.
+ */
+export function runWithSessionContext(context, callback) {
+    logger.log(`[SESSION_MANAGER] 🔐 Running with AsyncLocalStorage context`);
+    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
+    return asyncLocalStorage.run(context, callback);
+}
+/**
+ * Get the current session context from AsyncLocalStorage.
+ * This is the recommended way to access session context in tools.
+ * Returns null if not running within a session context.
+ */
+export function getCurrentSessionContext() {
+    const context = asyncLocalStorage.getStore() ?? null;
+    if (context) {
+        logger.log(`[SESSION_MANAGER] ✅ Got current session context from AsyncLocalStorage`);
+        logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+        logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
+    }
+    else {
+        logger.warn(`[SESSION_MANAGER] ⚠️  No session context in AsyncLocalStorage`);
+    }
+    return context;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * XY upload file tool - uploads local files to get publicly accessible URLs.
+ * Requires file URIs from search_file tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_file tool first to get URIs of files
+ * 2. Use the URIs to get public URLs
+ *
+ * Usage Note:
+ * - After getting public URLs, if further processing is needed, download the file first
+ * - URLs returned are publicly accessible
+ */
+export declare const uploadFileTool: any;