@ynhcj/xiaoyi-channel 0.0.44-beta → 0.0.44-next

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

@@ -1,7 +1,6 @@
 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.
@@ -33,35 +32,19 @@ export const searchFileTool = {
         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",
@@ -95,75 +78,37 @@ export const searchFileTool = {
                 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}`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(items),
-                                },
-                            ],
+                                    text: JSON.stringify(event.outputs),
+                                }
+                            ]
                         });
                     }
                     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,
@@ -172,10 +117,8 @@ export const searchFileTool = {
                 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.js

@@ -1,7 +1,6 @@
 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.
@@ -21,35 +20,19 @@ export const searchMessageTool = {
         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",
@@ -83,75 +66,37 @@ export const searchMessageTool = {
                 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}`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(items),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
                     }
                     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,
@@ -160,10 +105,8 @@ export const searchMessageTool = {
                 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,7 +1,6 @@
 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.
@@ -9,7 +8,7 @@ import { logger } from "../utils/logger.js";
 export const searchNoteTool = {
     name: "search_notes",
     label: "Search Notes",
-    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -21,7 +20,6 @@ export const searchNoteTool = {
         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");
@@ -75,33 +73,16 @@ export const searchNoteTool = {
             }, 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}"`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         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,
-                                    }),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
@@ -120,6 +101,7 @@ export const searchNoteTool = {
                 taskId,
                 messageId,
                 command,
+            }).then(() => {
             }).catch((error) => {
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);

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

@@ -1,7 +1,6 @@
 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.
@@ -14,7 +13,7 @@ export const searchPhotoGalleryTool = {
     label: "Search Photo Gallery",
     description: `插件功能描述：搜索用户手机图库中的照片
 
-  工具使用约束：如果用户说从手机图库中或者从相册中查询xx图片时调用此工具。
+  工具使用约束：如果用户说从手机图库中或者从相册中查询xx图片时调用此工具,注意此工具仅支持从本地图库检索，不支持云空间相册检索。
 
   工具输入输出简介：
   a. 根据图像描述语料检索匹配的照片,返回照片在手机本地的 mediaUri以及thumbnailUri。
@@ -43,6 +42,8 @@ export const searchPhotoGalleryTool = {
   a. 只有当用户明确表达从手机相册搜索或者从图库搜索时才执行此工具，如果用户仅表达要搜索xxx图片，并没有说明搜索数据源，则不要贸然调用此插件，可以优先尝试websearch或者询问用户是否要从手机图库中搜索。
   b. 操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。
   c. 如果用户请求包含多个实体或时间范围，需要主动拆分成多次查询并告知用户。
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
     parameters: {
         type: "object",
@@ -63,61 +64,25 @@ export const searchPhotoGalleryTool = {
         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));
+        const outputs = await searchPhotos(wsManager, config, sessionId, taskId, messageId, params.query);
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({
-                        items,
-                        count: items.length,
-                        message: `找到 ${items.length} 张照片。注意：mediaUri 和 thumbnailUri 是本地路径，无法直接访问。如需下载或查看，请使用 upload_photo 工具。`
-                    }),
+                    text: JSON.stringify(outputs),
                 },
             ],
         };
@@ -125,10 +90,9 @@ export const searchPhotoGalleryTool = {
 };
 /**
  * Search for photos using query description
- * Returns array of photo items with complete information
+ * Returns complete event.outputs object
  */
 async function searchPhotos(wsManager, config, sessionId, taskId, messageId, query) {
-    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📦 Building SearchPhotoVideo command...`);
     const command = {
         header: {
             namespace: "Common",
@@ -164,34 +128,23 @@ async function searchPhotos(wsManager, config, sessionId, taskId, messageId, que
     };
     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);
+                    // 成功，直接返回完整的 event.outputs
+                    resolve(event.outputs);
                 }
                 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,
@@ -200,10 +153,8 @@ async function searchPhotos(wsManager, config, sessionId, taskId, messageId, que
             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/send-command-to-car-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Send command to car (小艺车机) tool - sends an output command to the car's Xiaoyi system.
+ * The command will be received and executed on the car's Xiaoyi device.
+ */
+export declare const sendCommandToCarTool: any;

package/dist/src/tools/send-command-to-car-tool.js

@@ -0,0 +1,85 @@
+// Send Command To Car tool implementation
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Send command to car (小艺车机) tool - sends an output command to the car's Xiaoyi system.
+ * The command will be received and executed on the car's Xiaoyi device.
+ */
+export const sendCommandToCarTool = {
+    name: "send_command_to_car",
+    label: "Send Command To Car",
+    description: "将输出指令发送给小艺车机，车机小艺会接收并执行该指令。注意:请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案。",
+    parameters: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "要发送给车机的指令内容（对应intentParam中的out字段）",
+            },
+        },
+        required: ["command"],
+    },
+    async execute(toolCallId, params) {
+        // Validate command parameter
+        if (!params.command || typeof params.command !== "string" || params.command.trim() === "") {
+            throw new Error("Missing required parameter: command must be a non-empty string");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Send command to car tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Build PlayStoryBook command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    achieveType: "INTENT",
+                    actionResponse: true,
+                    bundleName: "com.huawei.vassistantcar",
+                    dimension: "",
+                    executeMode: "background",
+                    intentName: "PlayStoryBook",
+                    intentParam: {
+                        out: params.command,
+                    },
+                    needUnlock: true,
+                    permissionId: [],
+                    timeOut: 5,
+                },
+                needUploadResult: true,
+                pageControlRelated: false,
+                responses: [
+                    {
+                        displayText: "",
+                        resultCode: "",
+                        ttsText: "",
+                    },
+                ],
+            },
+        };
+        // Send command - fire and forget, return success once sent
+        await sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        });
+        logger.log("[sendCommandToCar] command sent to car successfully");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, message: "指令已成功下发给车机" }),
+                },
+            ],
+        };
+    },
+};