@ynhcj/xiaoyi-channel 0.0.26-beta → 0.0.28-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-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,290 @@
+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. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次`,
+    parameters: {
+        type: "object",
+        properties: {
+            fileLocalUrls: {
+                description: "本地文件路径数组，包含用户需要回传的文件在本地的地址",
+            },
+            fileRemoteUrls: {
+                description: "公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送）",
+            },
+        },
+    },
+    async execute(toolCallId, params) {
+        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} 个文件到用户设备`
+                    }),
+                },
+            ],
+        };
+    },
+};

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;