@ynhcj/xiaoyi-channel 1.1.3 → 1.1.5

package/dist/src/channel.js

@@ -5,8 +5,12 @@ import { xyOnboardingAdapter } from "./onboarding.js";
 import { locationTool } from "./tools/location-tool.js";
 import { noteTool } from "./tools/note-tool.js";
 import { searchNoteTool } from "./tools/search-note-tool.js";
+import { modifyNoteTool } from "./tools/modify-note-tool.js";
 import { calendarTool } from "./tools/calendar-tool.js";
 import { searchCalendarTool } from "./tools/search-calendar-tool.js";
+// import { searchContactTool } from "./tools/search-contact-tool.js"; // 暂时禁用
+import { searchPhotoGalleryTool } from "./tools/search-photo-gallery-tool.js";
+import { uploadPhotoTool } from "./tools/upload-photo-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -46,7 +50,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool, searchCalendarTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool], // searchContactTool 已暂时禁用
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

package/dist/src/reply-dispatcher.js

@@ -273,11 +273,6 @@ export function createXYReplyDispatcher(params) {
                 const text = payload.text ?? "";
                 const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
                 log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
-                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
-                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
-                if (text.length > 0) {
-                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
-                }
                 try {
                     if (text.length > 0) {
                         await sendReasoningTextUpdate({

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

@@ -0,0 +1,9 @@
+/**
+ * XY modify note tool - appends content to an existing note on user's device.
+ * Requires entityId from search_notes tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_notes tool first to get the entityId of target note
+ * 2. Use the entityId to append content to that note
+ */
+export declare const modifyNoteTool: any;

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

@@ -0,0 +1,163 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY modify note tool - appends content to an existing note on user's device.
+ * Requires entityId from search_notes tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_notes tool first to get the entityId of target note
+ * 2. Use the entityId to append content to that note
+ */
+export const modifyNoteTool = {
+    name: "modify_note",
+    label: "Modify Note",
+    description: "在指定备忘录中追加新内容。使用前必须先调用 search_notes 工具获取备忘录的 entityId。参数说明：entityId 是备忘录的唯一标识符（从 search_notes 工具获取），text 是要追加的文本内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            entityId: {
+                type: "string",
+                description: "备忘录的唯一标识符，必须先通过 search_notes 工具获取",
+            },
+            text: {
+                type: "string",
+                description: "要追加到备忘录的文本内容",
+            },
+        },
+        required: ["entityId", "text"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[MODIFY_NOTE_TOOL] 🚀 Starting execution`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[MODIFY_NOTE_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.entityId || !params.text) {
+            logger.error(`[MODIFY_NOTE_TOOL] ❌ Missing required parameters`);
+            throw new Error("Missing required parameters: entityId and text are required");
+        }
+        // Get session context
+        logger.log(`[MODIFY_NOTE_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            logger.error(`[MODIFY_NOTE_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Modify note tool can only be used during an active conversation.");
+        }
+        logger.log(`[MODIFY_NOTE_TOOL] ✅ Session context found`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[MODIFY_NOTE_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[MODIFY_NOTE_TOOL] ✅ WebSocket manager obtained`);
+        // Build ModifyNote command
+        logger.log(`[MODIFY_NOTE_TOOL] 📦 Building ModifyNote command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "ModifyNote",
+                    bundleName: "com.huawei.hmos.notepad",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        contentType: "1", // 1 = append mode (追加模式)
+                        text: params.text,
+                        entityId: params.entityId,
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        logger.log(`[MODIFY_NOTE_TOOL]   - entityId: ${params.entityId}`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - contentType: 1 (append mode)`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - text length: ${params.text.length} characters`);
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[MODIFY_NOTE_TOOL] ⏳ Setting up promise to wait for note modification response...`);
+        logger.log(`[MODIFY_NOTE_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[MODIFY_NOTE_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(`[MODIFY_NOTE_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "ModifyNote") {
+                    logger.log(`[MODIFY_NOTE_TOOL] 🎯 ModifyNote event received`);
+                    logger.log(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[MODIFY_NOTE_TOOL] ✅ Note modified successfully`);
+                        logger.log(`[MODIFY_NOTE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Return the result directly as requested
+                        const result = event.outputs.result;
+                        logger.log(`[MODIFY_NOTE_TOOL] 📝 Note updated:`);
+                        logger.log(`[MODIFY_NOTE_TOOL]   - entityId: ${result?.entityId}`);
+                        logger.log(`[MODIFY_NOTE_TOOL]   - title: ${result?.title}`);
+                        logger.log(`[MODIFY_NOTE_TOOL]   - modifiedDate: ${result?.modifiedDate}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[MODIFY_NOTE_TOOL] ❌ Note modification failed`);
+                        logger.error(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`修改备忘录失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[MODIFY_NOTE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[MODIFY_NOTE_TOOL] 📤 Sending ModifyNote command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[MODIFY_NOTE_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[MODIFY_NOTE_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

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

@@ -80,6 +80,17 @@ export const searchCalendarTool = {
             const date = new Date(year, month, day, hours, minutes, seconds);
             return date.getTime();
         };
+        // Helper function to convert timestamp to YYYYMMDD hhmmss format
+        const formatTimestamp = (timestamp) => {
+            const date = new Date(timestamp);
+            const year = date.getFullYear();
+            const month = String(date.getMonth() + 1).padStart(2, '0');
+            const day = String(date.getDate()).padStart(2, '0');
+            const hours = String(date.getHours()).padStart(2, '0');
+            const minutes = String(date.getMinutes()).padStart(2, '0');
+            const seconds = String(date.getSeconds()).padStart(2, '0');
+            return `${year}${month}${day} ${hours}${minutes}${seconds}`;
+        };
         let startTimeMs;
         let endTimeMs;
         try {
@@ -174,15 +185,43 @@ export const searchCalendarTool = {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events retrieved successfully`);
+                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events response received`);
                         logger.log(`[SEARCH_CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code in outputs
+                        if (event.outputs.retErrCode && event.outputs.retErrCode !== "0") {
+                            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Device returned error`);
+                            logger.error(`[SEARCH_CALENDAR_TOOL]   - retErrCode: ${event.outputs.retErrCode}`);
+                            logger.error(`[SEARCH_CALENDAR_TOOL]   - errMsg: ${event.outputs.errMsg || "Unknown error"}`);
+                            reject(new Error(`检索日程失败: ${event.outputs.errMsg || "未知错误"} (错误代码: ${event.outputs.retErrCode})`));
+                            return;
+                        }
                         // Return the result directly as requested
                         const result = event.outputs.result;
+                        // Ensure result is not undefined
+                        if (result === undefined) {
+                            logger.warn(`[SEARCH_CALENDAR_TOOL] ⚠️ Result is undefined, returning empty result`);
+                        }
+                        // Convert dtStart and dtEnd from timestamps to YYYYMMDD hhmmss format
+                        if (result && result.items && Array.isArray(result.items)) {
+                            logger.log(`[SEARCH_CALENDAR_TOOL] 🔄 Converting timestamps to formatted dates...`);
+                            result.items = result.items.map((item) => {
+                                const formattedItem = { ...item };
+                                if (item.dtStart) {
+                                    formattedItem.dtStart = formatTimestamp(item.dtStart);
+                                    logger.log(`[SEARCH_CALENDAR_TOOL]   - dtStart: ${item.dtStart} -> ${formattedItem.dtStart}`);
+                                }
+                                if (item.dtEnd) {
+                                    formattedItem.dtEnd = formatTimestamp(item.dtEnd);
+                                    logger.log(`[SEARCH_CALENDAR_TOOL]   - dtEnd: ${item.dtEnd} -> ${formattedItem.dtEnd}`);
+                                }
+                                return formattedItem;
+                            });
+                        }
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
+                                    text: result !== undefined ? JSON.stringify(result) : "[]",
                                 },
                             ],
                         });

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

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

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

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

package/dist/src/tools/search-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,175 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } 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图片时调用此工具。根据图像描述语料检索匹配的照片,返回照片在手机本地的 mediaUri。注意:返回的 mediaUri 是本地路径,无法直接下载或访问。如果需要下载、查看、使用或展示照片,请使用 upload_photo 工具将 mediaUri 转换为可访问的公网 URL。操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。注意事项：只有当用户明确表达从手机相册搜索或者从图库搜索时才执行此工具，如果用户仅表达要搜索xxx图片，并没有说明搜索数据源，则不要贸然调用此插件，可以优先尝试websearch或者询问用户是否要从手机图库中搜索。",
+    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 = getLatestSessionContext();
+        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 mediaUris = await searchPhotos(wsManager, config, sessionId, taskId, messageId, params.query);
+        if (!mediaUris || mediaUris.length === 0) {
+            logger.warn(`[SEARCH_PHOTO_GALLERY_TOOL] ⚠️ No photos found for query: ${params.query}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            mediaUris: [],
+                            count: 0,
+                            message: "未找到匹配的照片"
+                        }),
+                    },
+                ],
+            };
+        }
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ Found ${mediaUris.length} photos`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - mediaUris:`, JSON.stringify(mediaUris));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        mediaUris,
+                        count: mediaUris.length,
+                        message: `找到 ${mediaUris.length} 张照片。注意：这些是本地 URI，无法直接访问。如需下载或查看，请使用 upload_photo 工具。`
+                    }),
+                },
+            ],
+        };
+    },
+};
+/**
+ * Search for photos using query description
+ * Returns array of mediaUri strings
+ */
+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 || [];
+                    // Extract mediaUri from each item
+                    const mediaUris = items.map((item) => item.mediaUri).filter(Boolean);
+                    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] 📊 Extracted ${mediaUris.length} mediaUris`);
+                    resolve(mediaUris);
+                }
+                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;

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

@@ -0,0 +1,270 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * 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 const searchPhotoTool = {
+    name: "search_photo",
+    label: "Search Photo",
+    description: "搜索用户手机图库中的照片。根据图像描述语料检索匹配的照片，并返回照片的可公网访问URL。注意:操作超时时间为120秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "图像描述语料，用于检索匹配的照片（例如：'小狗的照片'、'带有键盘的图片'等）",
+            },
+        },
+        required: ["query"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_PHOTO_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_PHOTO_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.query) {
+            logger.error(`[SEARCH_PHOTO_TOOL] ❌ Missing required parameter: query`);
+            throw new Error("Missing required parameter: query is required");
+        }
+        // Get session context
+        logger.log(`[SEARCH_PHOTO_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_PHOTO_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_PHOTO_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search photo tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_PHOTO_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_PHOTO_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_PHOTO_TOOL] ✅ WebSocket manager obtained`);
+        // Step 1: Search for photos
+        logger.log(`[SEARCH_PHOTO_TOOL] 📸 STEP 1: Searching for photos...`);
+        const mediaUris = await searchPhotos(wsManager, config, sessionId, taskId, messageId, params.query);
+        if (!mediaUris || mediaUris.length === 0) {
+            logger.warn(`[SEARCH_PHOTO_TOOL] ⚠️ No photos found for query: ${params.query}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ imageUrls: [], message: "未找到匹配的照片" }),
+                    },
+                ],
+            };
+        }
+        logger.log(`[SEARCH_PHOTO_TOOL] ✅ Found ${mediaUris.length} photos`);
+        logger.log(`[SEARCH_PHOTO_TOOL]   - mediaUris:`, JSON.stringify(mediaUris));
+        // Step 2: Get public URLs for the photos
+        logger.log(`[SEARCH_PHOTO_TOOL] 🌐 STEP 2: Getting public URLs for photos...`);
+        const imageUrls = await getPhotoUrls(wsManager, config, sessionId, taskId, messageId, mediaUris);
+        logger.log(`[SEARCH_PHOTO_TOOL] 🎉 Successfully retrieved ${imageUrls.length} photo URLs`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ imageUrls }),
+                },
+            ],
+        };
+    },
+};
+/**
+ * Step 1: Search for photos using query description
+ * Returns array of mediaUri strings
+ */
+async function searchPhotos(wsManager, config, sessionId, taskId, messageId, query) {
+    logger.log(`[SEARCH_PHOTO_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_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_TOOL] 📨 Received data event (Step 1):`, JSON.stringify(event));
+            if (event.intentName === "SearchPhotoVideo") {
+                logger.log(`[SEARCH_PHOTO_TOOL] 🎯 SearchPhotoVideo event received`);
+                logger.log(`[SEARCH_PHOTO_TOOL]   - status: ${event.status}`);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                if (event.status === "success" && event.outputs) {
+                    logger.log(`[SEARCH_PHOTO_TOOL] ✅ Photo search completed successfully`);
+                    const result = event.outputs.result;
+                    const items = result?.items || [];
+                    // Extract mediaUri from each item
+                    const mediaUris = items.map((item) => item.mediaUri).filter(Boolean);
+                    logger.log(`[SEARCH_PHOTO_TOOL] 📊 Extracted ${mediaUris.length} mediaUris`);
+                    resolve(mediaUris);
+                }
+                else {
+                    logger.error(`[SEARCH_PHOTO_TOOL] ❌ Photo search failed`);
+                    logger.error(`[SEARCH_PHOTO_TOOL]   - status: ${event.status}`);
+                    reject(new Error(`搜索照片失败: ${event.status}`));
+                }
+            }
+        };
+        logger.log(`[SEARCH_PHOTO_TOOL] 📡 Registering data-event handler for SearchPhotoVideo`);
+        wsManager.on("data-event", handler);
+        logger.log(`[SEARCH_PHOTO_TOOL] 📤 Sending SearchPhotoVideo command...`);
+        sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        })
+            .then(() => {
+            logger.log(`[SEARCH_PHOTO_TOOL] ✅ SearchPhotoVideo command sent successfully`);
+        })
+            .catch((error) => {
+            logger.error(`[SEARCH_PHOTO_TOOL] ❌ Failed to send SearchPhotoVideo command:`, error);
+            clearTimeout(timeout);
+            wsManager.off("data-event", handler);
+            reject(error);
+        });
+    });
+}
+/**
+ * Step 2: Get public URLs for photos using mediaUris
+ * Returns array of publicly accessible image URLs
+ */
+async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, mediaUris) {
+    logger.log(`[SEARCH_PHOTO_TOOL] 📦 Building ImageUploadForClaw command...`);
+    // Build imageInfos array from mediaUris
+    const imageInfos = mediaUris.map(mediaUri => ({ mediaUri }));
+    const command = {
+        header: {
+            namespace: "Common",
+            name: "Action",
+        },
+        payload: {
+            cardParam: {},
+            executeParam: {
+                executeMode: "background",
+                intentName: "ImageUploadForClaw",
+                bundleName: "com.huawei.hmos.vassistant",
+                needUnlock: true,
+                actionResponse: true,
+                appType: "OHOS_APP",
+                timeOut: 5,
+                intentParam: {
+                    imageInfos: imageInfos,
+                },
+                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_TOOL] ⏰ Timeout: No response for ImageUploadForClaw within 60 seconds`);
+            wsManager.off("data-event", handler);
+            reject(new Error("获取照片URL超时（60秒）"));
+        }, 60000);
+        const handler = (event) => {
+            logger.log(`[SEARCH_PHOTO_TOOL] 📨 Received data event (Step 2):`, JSON.stringify(event));
+            if (event.intentName === "ImageUploadForClaw") {
+                logger.log(`[SEARCH_PHOTO_TOOL] 🎯 ImageUploadForClaw event received`);
+                logger.log(`[SEARCH_PHOTO_TOOL]   - status: ${event.status}`);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                if (event.status === "success" && event.outputs) {
+                    logger.log(`[SEARCH_PHOTO_TOOL] ✅ Image URL retrieval completed successfully`);
+                    const result = event.outputs.result;
+                    let imageUrls = result?.imageUrls || [];
+                    // Decode Unicode escape sequences in URLs
+                    // Replace \u003d with = and \u0026 with &
+                    imageUrls = imageUrls.map((url) => {
+                        const decodedUrl = url
+                            .replace(/\\u003d/g, '=')
+                            .replace(/\\u0026/g, '&');
+                        logger.log(`[SEARCH_PHOTO_TOOL] 🔄 Decoded URL: ${url} -> ${decodedUrl}`);
+                        return decodedUrl;
+                    });
+                    logger.log(`[SEARCH_PHOTO_TOOL] 📊 Retrieved and decoded ${imageUrls.length} image URLs`);
+                    resolve(imageUrls);
+                }
+                else {
+                    logger.error(`[SEARCH_PHOTO_TOOL] ❌ Image URL retrieval failed`);
+                    logger.error(`[SEARCH_PHOTO_TOOL]   - status: ${event.status}`);
+                    reject(new Error(`获取照片URL失败: ${event.status}`));
+                }
+            }
+        };
+        logger.log(`[SEARCH_PHOTO_TOOL] 📡 Registering data-event handler for ImageUploadForClaw`);
+        wsManager.on("data-event", handler);
+        logger.log(`[SEARCH_PHOTO_TOOL] 📤 Sending ImageUploadForClaw command...`);
+        sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        })
+            .then(() => {
+            logger.log(`[SEARCH_PHOTO_TOOL] ✅ ImageUploadForClaw command sent successfully`);
+        })
+            .catch((error) => {
+            logger.error(`[SEARCH_PHOTO_TOOL] ❌ Failed to send ImageUploadForClaw command:`, error);
+            clearTimeout(timeout);
+            wsManager.off("data-event", handler);
+            reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * XY upload photo tool - uploads local photos to get publicly accessible URLs.
+ * Requires mediaUris from search_photo_gallery tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_photo_gallery tool first to get mediaUris of photos
+ * 2. Use the mediaUris (maximum 5 at a time) to get public URLs
+ */
+export declare const uploadPhotoTool: any;

package/dist/src/tools/upload-photo-tool.js

@@ -0,0 +1,213 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY upload photo tool - uploads local photos to get publicly accessible URLs.
+ * Requires mediaUris from search_photo_gallery tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_photo_gallery tool first to get mediaUris of photos
+ * 2. Use the mediaUris (maximum 5 at a time) to get public URLs
+ */
+export const uploadPhotoTool = {
+    name: "upload_photo",
+    label: "Upload Photo",
+    description: "将手机本地照片回传并获取可公网访问的 URL。使用前必须先调用 search_photo_gallery 工具获取照片的 mediaUri，必须与search_photo_gallery中的mediaUri完全保持一致，不要修改。参数说明：mediaUris 是照片在手机本地的 URI 数组或 JSON 字符串数组（从 search_photo_gallery 工具获取）。限制：每次最多支持传入 5 条 mediaUri。操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。注意事项：此工具返回的图片链接为用户公网可访问的链接，如果需要后续操作需要下载到本地，如果需要返回给用户查看则直接以图片markdown的形式返回给用户",
+    parameters: {
+        type: "object",
+        properties: {
+            mediaUris: {
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "照片在手机本地的 URI 数组（或 JSON 字符串形式的数组），必须先通过 search_photo_gallery 工具获取。每次最多支持 5 条 URI。支持传入数组 [\"uri1\", \"uri2\"] 或 JSON 字符串 '[\"uri1\", \"uri2\"]'。",
+            },
+        },
+        required: ["mediaUris"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[UPLOAD_PHOTO_TOOL] 🚀 Starting execution`);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - params (raw):`, JSON.stringify(params));
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - params.mediaUris type:`, typeof params.mediaUris);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // ===== 参数规范化：兼容数组和 JSON 字符串 =====
+        let mediaUris = null;
+        if (!params.mediaUris) {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Missing parameter: mediaUris`);
+            throw new Error("Missing required parameter: mediaUris");
+        }
+        // 情况1: 已经是数组
+        if (Array.isArray(params.mediaUris)) {
+            logger.log(`[UPLOAD_PHOTO_TOOL] ✅ mediaUris is already an array`);
+            mediaUris = params.mediaUris;
+        }
+        // 情况2: 是字符串，尝试解析为 JSON 数组
+        else if (typeof params.mediaUris === 'string') {
+            logger.log(`[UPLOAD_PHOTO_TOOL] 🔄 mediaUris is a string, attempting to parse as JSON...`);
+            try {
+                const parsed = JSON.parse(params.mediaUris);
+                if (Array.isArray(parsed)) {
+                    logger.log(`[UPLOAD_PHOTO_TOOL] ✅ Successfully parsed JSON string to array`);
+                    mediaUris = parsed;
+                }
+                else {
+                    logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Parsed JSON is not an array:`, typeof parsed);
+                    throw new Error("mediaUris must be an array or a JSON string representing an array");
+                }
+            }
+            catch (parseError) {
+                logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Failed to parse mediaUris as JSON:`, parseError);
+                throw new Error(`mediaUris must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+            }
+        }
+        // 情况3: 其他类型，报错
+        else {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Invalid mediaUris type:`, typeof params.mediaUris);
+            throw new Error(`mediaUris must be an array or a JSON string, got ${typeof params.mediaUris}`);
+        }
+        // 验证数组非空
+        if (!mediaUris || mediaUris.length === 0) {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ mediaUris array is empty`);
+            throw new Error("mediaUris array cannot be empty");
+        }
+        logger.log(`[UPLOAD_PHOTO_TOOL] ✅ Normalized mediaUris:`, JSON.stringify(mediaUris));
+        // Validate maximum 5 URIs
+        if (mediaUris.length > 5) {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Too many mediaUris: ${mediaUris.length}`);
+            throw new Error(`最多支持 5 条 mediaUri，当前提供了 ${mediaUris.length} 条。请分批处理。`);
+        }
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - mediaUris count: ${mediaUris.length}`);
+        // Get session context
+        logger.log(`[UPLOAD_PHOTO_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[UPLOAD_PHOTO_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Upload photo tool can only be used during an active conversation.");
+        }
+        logger.log(`[UPLOAD_PHOTO_TOOL] ✅ Session context found`);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[UPLOAD_PHOTO_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[UPLOAD_PHOTO_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[UPLOAD_PHOTO_TOOL] ✅ WebSocket manager obtained`);
+        // Get public URLs for the photos
+        logger.log(`[UPLOAD_PHOTO_TOOL] 🌐 Getting public URLs for photos...`);
+        const imageUrls = await getPhotoUrls(wsManager, config, sessionId, taskId, messageId, mediaUris);
+        logger.log(`[UPLOAD_PHOTO_TOOL] 🎉 Successfully retrieved ${imageUrls.length} photo URLs`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        imageUrls,
+                        count: imageUrls.length,
+                        message: `成功获取 ${imageUrls.length} 张照片的公网访问 URL`
+                    }),
+                },
+            ],
+        };
+    },
+};
+/**
+ * Get public URLs for photos using mediaUris
+ * Returns array of publicly accessible image URLs
+ */
+async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, mediaUris) {
+    logger.log(`[UPLOAD_PHOTO_TOOL] 📦 Building ImageUploadForClaw command...`);
+    // Build imageInfos array from mediaUris
+    const imageInfos = mediaUris.map(mediaUri => ({ mediaUri }));
+    const command = {
+        header: {
+            namespace: "Common",
+            name: "Action",
+        },
+        payload: {
+            cardParam: {},
+            executeParam: {
+                executeMode: "background",
+                intentName: "ImageUploadForClaw",
+                bundleName: "com.huawei.hmos.vassistant",
+                needUnlock: true,
+                actionResponse: true,
+                appType: "OHOS_APP",
+                timeOut: 5,
+                intentParam: {
+                    imageInfos: imageInfos,
+                },
+                permissionId: [],
+                achieveType: "INTENT",
+            },
+            responses: [
+                {
+                    resultCode: "",
+                    displayText: "",
+                    ttsText: "",
+                },
+            ],
+            needUploadResult: true,
+            noHalfPage: false,
+            pageControlRelated: false,
+        },
+    };
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ⏰ Timeout: No response for ImageUploadForClaw within 60 seconds`);
+            wsManager.off("data-event", handler);
+            reject(new Error("获取照片URL超时（60秒）"));
+        }, 60000);
+        const handler = (event) => {
+            logger.log(`[UPLOAD_PHOTO_TOOL] 📨 Received data event:`, JSON.stringify(event));
+            if (event.intentName === "ImageUploadForClaw") {
+                logger.log(`[UPLOAD_PHOTO_TOOL] 🎯 ImageUploadForClaw event received`);
+                logger.log(`[UPLOAD_PHOTO_TOOL]   - status: ${event.status}`);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                if (event.status === "success" && event.outputs) {
+                    logger.log(`[UPLOAD_PHOTO_TOOL] ✅ Image URL retrieval completed successfully`);
+                    const result = event.outputs.result;
+                    let imageUrls = result?.imageUrls || [];
+                    // Decode Unicode escape sequences in URLs
+                    // Replace \u003d with = and \u0026 with &
+                    imageUrls = imageUrls.map((url) => {
+                        const decodedUrl = url
+                            .replace(/\\u003d/g, '=')
+                            .replace(/\\u0026/g, '&');
+                        logger.log(`[UPLOAD_PHOTO_TOOL] 🔄 Decoded URL: ${url} -> ${decodedUrl}`);
+                        return decodedUrl;
+                    });
+                    logger.log(`[UPLOAD_PHOTO_TOOL] 📊 Retrieved and decoded ${imageUrls.length} image URLs`);
+                    resolve(imageUrls);
+                }
+                else {
+                    logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Image URL retrieval failed`);
+                    logger.error(`[UPLOAD_PHOTO_TOOL]   - status: ${event.status}`);
+                    reject(new Error(`获取照片URL失败: ${event.status}`));
+                }
+            }
+        };
+        logger.log(`[UPLOAD_PHOTO_TOOL] 📡 Registering data-event handler for ImageUploadForClaw`);
+        wsManager.on("data-event", handler);
+        logger.log(`[UPLOAD_PHOTO_TOOL] 📤 Sending ImageUploadForClaw command...`);
+        sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        })
+            .then(() => {
+            logger.log(`[UPLOAD_PHOTO_TOOL] ✅ ImageUploadForClaw command sent successfully`);
+        })
+            .catch((error) => {
+            logger.error(`[UPLOAD_PHOTO_TOOL] ❌ Failed to send ImageUploadForClaw command:`, error);
+            clearTimeout(timeout);
+            wsManager.off("data-event", handler);
+            reject(error);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",