@ynhcj/xiaoyi-channel 0.0.46-beta → 0.0.48-beta

package/dist/src/bot.js

@@ -329,9 +329,7 @@ function buildXYMediaPayload(mediaList) {
     return {
         MediaPath: first?.path,
         MediaType: first?.mimeType,
-        MediaUrl: first?.path,
         MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
-        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }

package/dist/src/channel.js

@@ -22,8 +22,9 @@ import { searchAlarmTool } from "./tools/search-alarm-tool.js";
 import { modifyAlarmTool } from "./tools/modify-alarm-tool.js";
 import { deleteAlarmTool } from "./tools/delete-alarm-tool.js";
 import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
-import { xiaoyiCollectionTool } from "./tools/xiaoyi-collection-tool.js";
+// import { xiaoyiCollectionTool } from "./tools/xiaoyi-collection-tool.js"; // 暂时取消注册
 import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -63,7 +64,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, sendMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, xiaoyiCollectionTool, viewPushResultTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, sendMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, viewPushResultTool, imageReadingTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

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

@@ -12,6 +12,11 @@ export declare class XYFileUploadService {
      * Returns the objectId (as fileId) for use in A2A messages.
      */
     uploadFile(filePath: string, objectType?: string): Promise<string>;
+    /**
+     * Upload a file and return its publicly accessible URL.
+     * Uses completeAndQuery endpoint to get the file URL directly.
+     */
+    uploadFileAndGetUrl(filePath: string, objectType?: string): Promise<string>;
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/file-upload.js

@@ -105,6 +105,98 @@ export class XYFileUploadService {
             return "";
         }
     }
+    /**
+     * Upload a file and return its publicly accessible URL.
+     * Uses completeAndQuery endpoint to get the file URL directly.
+     */
+    async uploadFileAndGetUrl(filePath, objectType = "TEMPORARY_MATERIAL_DOC") {
+        console.log(`[XY File Upload] Starting file upload with URL retrieval: ${filePath}`);
+        try {
+            // Read file
+            const fileBuffer = await fs.readFile(filePath);
+            const fileName = path.basename(filePath);
+            const fileSha256 = calculateSHA256(fileBuffer);
+            const fileSize = fileBuffer.length;
+            // Phase 1: Prepare
+            console.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
+            const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectType,
+                    fileName,
+                    fileSha256,
+                    fileSize,
+                    fileOwnerInfo: {
+                        uid: this.uid,
+                        teamId: this.uid,
+                    },
+                    useEdge: false,
+                }),
+            });
+            if (!prepareResp.ok) {
+                throw new Error(`Prepare failed: HTTP ${prepareResp.status}`);
+            }
+            const prepareData = await prepareResp.json();
+            console.log(`[XY File Upload] Prepare response:`, JSON.stringify(prepareData, null, 2));
+            if (prepareData.code !== "0") {
+                throw new Error(`Prepare failed: ${prepareData.desc}`);
+            }
+            const { objectId, draftId, uploadInfos } = prepareData;
+            console.log(`[XY File Upload] Prepare complete: objectId=${objectId}, draftId=${draftId}`);
+            // Phase 2: Upload
+            console.log(`[XY File Upload] Phase 2: Upload file data`);
+            const uploadInfo = uploadInfos[0]; // Single-part upload
+            const uploadResp = await fetch(uploadInfo.url, {
+                method: uploadInfo.method,
+                headers: uploadInfo.headers,
+                body: fileBuffer,
+            });
+            console.log(`[XY File Upload] Upload response status: ${uploadResp.status}`);
+            if (!uploadResp.ok) {
+                const uploadErrorText = await uploadResp.text();
+                console.log(`[XY File Upload] Upload error response:`, uploadErrorText);
+                throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
+            }
+            console.log(`[XY File Upload] Upload complete`);
+            // Phase 3: CompleteAndQuery - get file URL
+            console.log(`[XY File Upload] Phase 3: CompleteAndQuery to get file URL`);
+            const completeResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/completeAndQuery`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectId,
+                    draftId,
+                }),
+            });
+            if (!completeResp.ok) {
+                throw new Error(`CompleteAndQuery failed: HTTP ${completeResp.status}`);
+            }
+            const completeData = await completeResp.json();
+            console.log(`[XY File Upload] CompleteAndQuery response:`, JSON.stringify(completeData, null, 2));
+            // Extract file URL from response
+            const fileUrl = completeData?.fileDetailInfo?.url || "";
+            if (!fileUrl) {
+                throw new Error("No file URL returned from completeAndQuery");
+            }
+            console.log(`[XY File Upload] File upload successful: ${fileName} → URL=${fileUrl}`);
+            return fileUrl;
+        }
+        catch (error) {
+            console.error(`[XY File Upload] File upload with URL retrieval failed for ${filePath}:`, error);
+            throw error;
+        }
+    }
     /**
      * Upload multiple files and return their file IDs.
      */

package/dist/src/tools/create-alarm-tool.js

@@ -302,16 +302,6 @@ b. 使用该工具之前需获取当前真实时间`,
                     if (event.status === "success" && event.outputs) {
                         logger.log(`[CREATE_ALARM_TOOL] ✅ Alarm creation completed successfully`);
                         logger.log(`[CREATE_ALARM_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(`[CREATE_ALARM_TOOL] ❌ Device returned error`);
-                            logger.error(`[CREATE_ALARM_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[CREATE_ALARM_TOOL]   - errorMsg: ${errorMsg}`);
-                            reject(new Error(`创建闹钟失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [

package/dist/src/tools/delete-alarm-tool.js

@@ -172,18 +172,7 @@ export const deleteAlarmTool = {
                     if (event.status === "success" && event.outputs) {
                         logger.log(`[DELETE_ALARM_TOOL] ✅ Alarm deletion completed successfully`);
                         logger.log(`[DELETE_ALARM_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(`[DELETE_ALARM_TOOL] ❌ Device returned error`);
-                            logger.error(`[DELETE_ALARM_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[DELETE_ALARM_TOOL]   - errorMsg: ${errorMsg}`);
-                            reject(new Error(`删除闹钟失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
                         // 成功，直接返回完整的 event.outputs JSON 字符串
-                        logger.log(`[DELETE_ALARM_TOOL] 🎉 Successfully deleted ${items.length} alarm(s)`);
                         resolve({
                             content: [
                                 {

package/dist/src/tools/image-reading-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY Image Reading tool - performs image understanding using local or remote image URLs.
+ * Supports both local file paths and remote URLs.
+ */
+export declare const imageReadingTool: any;

package/dist/src/tools/image-reading-tool.js

@@ -0,0 +1,353 @@
+// Image Reading tool implementation
+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";
+import { v4 as uuidv4 } from "uuid";
+/**
+ * Check if value is a remote URL
+ */
+function isRemoteUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if value is a local file path
+ */
+async function isLocalFile(value) {
+    try {
+        const stats = await fs.stat(value);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Download remote file to local temp directory
+ */
+async function downloadRemoteFile(url) {
+    logger.log(`[IMAGE_READING_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_image";
+        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) || ".jpg";
+        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(`[IMAGE_READING_TOOL] ✅ File downloaded to: ${localPath}`);
+        return localPath;
+    }
+    catch (error) {
+        logger.error(`[IMAGE_READING_TOOL] ❌ Failed to download file from ${url}:`, error);
+        throw new Error(`Failed to download remote file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Process image input: validate and convert local file to OBS URL, keep remote URL unchanged
+ */
+async function processImageInput(imageInput, uploadService) {
+    logger.log(`[IMAGE_READING_TOOL] 🔄 Processing image input: ${imageInput}`);
+    // Check if it's a remote URL
+    if (isRemoteUrl(imageInput)) {
+        logger.log(`[IMAGE_READING_TOOL] 🌐 Input is remote URL, downloading...`);
+        const localPath = await downloadRemoteFile(imageInput);
+        logger.log(`[IMAGE_READING_TOOL] 📤 Uploading downloaded file to OBS...`);
+        const imageUrl = await uploadService.uploadFileAndGetUrl(localPath, "TEMPORARY_MATERIAL_DOC");
+        logger.log(`[IMAGE_READING_TOOL] ✅ Uploaded to OBS: ${imageUrl}`);
+        return { imageUrl, localPath };
+    }
+    // Check if it's a local file
+    const isLocal = await isLocalFile(imageInput);
+    if (isLocal) {
+        logger.log(`[IMAGE_READING_TOOL] 📁 Input is local file, uploading...`);
+        const imageUrl = await uploadService.uploadFileAndGetUrl(imageInput, "TEMPORARY_MATERIAL_DOC");
+        logger.log(`[IMAGE_READING_TOOL] ✅ Uploaded to OBS: ${imageUrl}`);
+        return { imageUrl };
+    }
+    throw new Error(`Invalid image input: must be a remote URL or local file path, got: ${imageInput}`);
+}
+/**
+ * Call image understanding API with streaming response
+ */
+async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid) {
+    logger.log(`[IMAGE_READING_TOOL] 🧠 Calling image understanding API...`);
+    logger.log(`[IMAGE_READING_TOOL]   - imageUrl: ${imageUrl}`);
+    logger.log(`[IMAGE_READING_TOOL]   - prompt: ${text}`);
+    const apiUrl = "https://hag-drcn.op.dbankcloud.com/celia-claw/v1/sse-api/skill/execute";
+    const traceId = uuidv4();
+    const headers = {
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream",
+        "x-hag-trace-id": traceId,
+        "x-api-key": apiKey,
+        "x-request-from": "openclaw",
+        "x-uid": uid,
+        "x-skill-id": "image_comprehension",
+        "x-prd-pkg-name": "com.huawei.hag",
+    };
+    const payload = {
+        version: "1.0",
+        session: {
+            isNew: false,
+            sessionId: "wangyu202410241921",
+            interactionId: 0,
+        },
+        endpoint: {
+            device: {
+                sid: "3df83a4a8124d7600f66206f96ea1e7e4e21c593adc4246bd20d450d8404cbf3",
+                deviceId: "3f35019f-ba4c-4ed5-80c0-6ddcef741200",
+                prdVer: "99.0.64.303",
+                phoneType: "WLZ-AL10",
+                sysVer: "HarmonyOS_2.0.0",
+                deviceType: 0,
+                timezone: "GMT+08:00",
+            },
+            locale: "zh-CN",
+            sysLocale: "zh",
+            countryCode: "CN",
+        },
+        utterance: { type: "text", original: text },
+        actions: [
+            {
+                actionSn: uuidv4(),
+                actionExecutorTask: {
+                    pluginId: "aeac4e92c32949c1b7fc02de262615e6",
+                    agentState: "OnShelf",
+                    actionName: "imageUnderStandStream",
+                    content: { imageUrl, text },
+                },
+            },
+        ],
+    };
+    logger.log(`[IMAGE_READING_TOOL] 📡 Sending request with trace ID: ${traceId}`);
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            // @ts-ignore - node-fetch supports this
+            timeout: 120000, // 2 minutes timeout
+        });
+        logger.log(`[IMAGE_READING_TOOL] 📨 Response status: ${response.status}`);
+        logger.log(`[IMAGE_READING_TOOL] 📨 Content-Type: ${response.headers.get("Content-Type")}`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.error(`[IMAGE_READING_TOOL] ❌ API request failed: ${response.status}`);
+            logger.error(`[IMAGE_READING_TOOL] ❌ Response: ${errorText}`);
+            throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+        }
+        // Process SSE stream
+        let lastCaption = "";
+        let lineCount = 0;
+        let buffer = "";
+        logger.log(`[IMAGE_READING_TOOL] 📖 Reading SSE stream...`);
+        // Read the response body as a stream
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        for await (const chunk of response.body) {
+            if (!chunk)
+                continue;
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                lineCount++;
+                const trimmedLine = line.replace(/\r$/, "");
+                if (!trimmedLine)
+                    continue;
+                if (trimmedLine.startsWith("data:")) {
+                    const dataContent = trimmedLine.substring(5).trim();
+                    if (dataContent && dataContent !== "[DONE]") {
+                        try {
+                            const dataJson = JSON.parse(dataContent);
+                            // Extract streamContent from abilityInfos
+                            if (dataJson.abilityInfos && Array.isArray(dataJson.abilityInfos)) {
+                                for (const info of dataJson.abilityInfos) {
+                                    if (info.actionExecutorResult?.reply?.streamInfo) {
+                                        const streamContent = info.actionExecutorResult.reply.streamInfo.streamContent;
+                                        if (streamContent) {
+                                            lastCaption = streamContent;
+                                            logger.log(`[IMAGE_READING_TOOL] 📝 Updated caption (length: ${streamContent.length})`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (parseError) {
+                            logger.warn(`[IMAGE_READING_TOOL] ⚠️ Failed to parse JSON data:`, parseError);
+                        }
+                    }
+                }
+            }
+        }
+        logger.log(`[IMAGE_READING_TOOL] ✅ Stream processing complete`);
+        logger.log(`[IMAGE_READING_TOOL]   - Total lines processed: ${lineCount}`);
+        logger.log(`[IMAGE_READING_TOOL]   - Final caption length: ${lastCaption.length}`);
+        if (!lastCaption) {
+            throw new Error("No caption received from image understanding API");
+        }
+        return lastCaption;
+    }
+    catch (error) {
+        logger.error(`[IMAGE_READING_TOOL] ❌ API call failed:`, error);
+        throw error;
+    }
+}
+/**
+ * XY Image Reading tool - performs image understanding using local or remote image URLs.
+ * Supports both local file paths and remote URLs.
+ */
+export const imageReadingTool = {
+    name: "image_reading",
+    label: "Image Reading",
+    description: `
+工具使用场景：
+【必须调用此工具的情况】
+1. 用户消息中包含 mediaPath 字段且不为空（表示用户发送了图片）
+2. 用户希望理解图片内容，询问图片是什么，例如：
+   - "这是什么？"
+   - "图片里有什么？"
+   - "帮我看看这张图"
+   - "描述一下这张图片"
+   - "分析一下这张照片"
+   - "这个图片是什么意思"
+   - "识别一下图片内容"
+   - 或任何关于图片内容的理解、识别、分析类询问
+
+当同时满足以上两个条件时，必须优先调用此工具进行图像理解。
+
+工具能力描述：对图片进行理解和分析，返回图片的描述内容。
+
+工具参数说明：
+a. localUrl：本地图片文件路径（可选，通常从用户消息的 mediaPath 字段获取）
+b. remoteUrl：公网图片地址（可选）
+c. prompt：对图片的提示问题，默认为"描述这张图片内容"，可根据用户的具体问题自定义
+d. localUrl 与 remoteUrl 任意一个不为空即可，优先使用 localUrl
+
+注意事项：
+a. 支持常见图片格式（jpg, png, gif等）
+b. 远程图片会先下载到本地再处理
+c. 操作超时时间为2分钟（120秒）
+d. 返回图像理解的文本描述内容`,
+    parameters: {
+        type: "object",
+        properties: {
+            localUrl: {
+                type: "string",
+                description: "本地图片文件路径",
+            },
+            remoteUrl: {
+                type: "string",
+                description: "公网图片地址（HTTP/HTTPS URL）",
+            },
+            prompt: {
+                type: "string",
+                description: "对图片的提示问题，默认为'描述这张图片内容'",
+            },
+        },
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[IMAGE_READING_TOOL] 🚀 Starting execution`);
+        logger.log(`[IMAGE_READING_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[IMAGE_READING_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[IMAGE_READING_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate that at least one parameter is provided
+        if (!params.localUrl && !params.remoteUrl) {
+            logger.error(`[IMAGE_READING_TOOL] ❌ Missing both localUrl and remoteUrl parameters`);
+            throw new Error("At least one of localUrl or remoteUrl must be provided");
+        }
+        // Get prompt (default to "描述这张图片内容")
+        const prompt = params.prompt || "描述这张图片内容";
+        logger.log(`[IMAGE_READING_TOOL] 📝 Using prompt: ${prompt}`);
+        // Get session context
+        logger.log(`[IMAGE_READING_TOOL] 🔍 Getting session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[IMAGE_READING_TOOL] ❌ No active session found!`);
+            throw new Error("No active XY session found. Image reading tool can only be used during an active conversation.");
+        }
+        logger.log(`[IMAGE_READING_TOOL] ✅ Session context found`);
+        const { config } = sessionContext;
+        // Create upload service
+        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+        let processedImage = null;
+        let downloadedFile = null;
+        try {
+            // Process image input (prefer localUrl over remoteUrl)
+            const imageInput = params.localUrl || params.remoteUrl;
+            logger.log(`[IMAGE_READING_TOOL] 🖼️ Processing image: ${imageInput}`);
+            processedImage = await processImageInput(imageInput, uploadService);
+            // Track downloaded file for cleanup
+            if (processedImage.localPath) {
+                downloadedFile = processedImage.localPath;
+            }
+            logger.log(`[IMAGE_READING_TOOL] ✅ Image processed successfully`);
+            logger.log(`[IMAGE_READING_TOOL]   - OBS URL: ${processedImage.imageUrl}`);
+            // Call image understanding API
+            const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid);
+            logger.log(`[IMAGE_READING_TOOL] 🎉 Image understanding completed successfully`);
+            logger.log(`[IMAGE_READING_TOOL]   - Caption length: ${caption.length} characters`);
+            // Clean up downloaded file if any
+            if (downloadedFile) {
+                logger.log(`[IMAGE_READING_TOOL] 🧹 Cleaning up downloaded file...`);
+                try {
+                    await fs.unlink(downloadedFile);
+                    logger.log(`[IMAGE_READING_TOOL] ✅ Cleaned up: ${downloadedFile}`);
+                }
+                catch (error) {
+                    logger.warn(`[IMAGE_READING_TOOL] ⚠️ Failed to clean up file:`, error);
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            caption,
+                            prompt,
+                            imageSource: params.localUrl ? "local" : "remote",
+                            success: true,
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // Clean up downloaded file on error
+            if (downloadedFile) {
+                logger.log(`[IMAGE_READING_TOOL] 🧹 Cleaning up downloaded file after error...`);
+                try {
+                    await fs.unlink(downloadedFile);
+                }
+                catch (cleanupError) {
+                    logger.warn(`[IMAGE_READING_TOOL] ⚠️ Failed to clean up file:`, cleanupError);
+                }
+            }
+            logger.error(`[IMAGE_READING_TOOL] ❌ Execution failed:`, error);
+            throw error;
+        }
+    },
+};

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

@@ -319,16 +319,6 @@ export const modifyAlarmTool = {
                     if (event.status === "success" && event.outputs) {
                         logger.log(`[MODIFY_ALARM_TOOL] ✅ Alarm modification completed successfully`);
                         logger.log(`[MODIFY_ALARM_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(`[MODIFY_ALARM_TOOL] ❌ Device returned error`);
-                            logger.error(`[MODIFY_ALARM_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[MODIFY_ALARM_TOOL]   - errorMsg: ${errorMsg}`);
-                            reject(new Error(`修改闹钟失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [

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

@@ -225,63 +225,15 @@ b. 使用该工具之前需获取当前真实时间`,
                     if (event.status === "success" && event.outputs) {
                         logger.log(`[SEARCH_ALARM_TOOL] ✅ Alarm search completed successfully`);
                         logger.log(`[SEARCH_ALARM_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_ALARM_TOOL] ❌ Device returned error`);
-                            logger.error(`[SEARCH_ALARM_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[SEARCH_ALARM_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_ALARM_TOOL] 📋 Found ${items.length} alarm(s)`);
-                            // Parse JSON strings in items array
-                            // Items are returned as JSON strings that need to be parsed
-                            const parsedItems = items.map((itemStr, index) => {
-                                if (typeof itemStr !== "string") {
-                                    logger.warn(`[SEARCH_ALARM_TOOL] ⚠️ Item at index ${index} is not a string:`, typeof itemStr);
-                                    return null;
-                                }
-                                try {
-                                    const parsed = JSON.parse(itemStr);
-                                    logger.log(`[SEARCH_ALARM_TOOL] 📋 Parsed alarm [${index}]:`, JSON.stringify(parsed));
-                                    return parsed;
-                                }
-                                catch (parseError) {
-                                    logger.error(`[SEARCH_ALARM_TOOL] ❌ Failed to parse item at index ${index}:`, parseError);
-                                    logger.error(`[SEARCH_ALARM_TOOL]   - itemStr: ${itemStr}`);
-                                    return null;
-                                }
-                            }).filter((item) => item !== null);
-                            logger.log(`[SEARCH_ALARM_TOOL] 🎉 Successfully parsed ${parsedItems.length} alarm(s)`);
-                            resolve({
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify(parsedItems),
-                                    },
-                                ],
-                            });
-                        }
-                        else {
-                            logger.warn(`[SEARCH_ALARM_TOOL] ⚠️ No items found in result or result is invalid`);
-                            logger.warn(`[SEARCH_ALARM_TOOL]   - result:`, JSON.stringify(result || {}));
-                            // Return empty array
-                            resolve({
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: "[]",
-                                    },
-                                ],
-                            });
-                        }
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
                     }
                     else {
                         logger.error(`[SEARCH_ALARM_TOOL] ❌ Alarm search failed`);

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

@@ -83,17 +83,6 @@ b. 使用该工具之前需获取当前真实时间
             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 {
@@ -188,43 +177,14 @@ b. 使用该工具之前需获取当前真实时间
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events response received`);
+                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events retrieved successfully`);
                         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;
-                            });
-                        }
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: result !== undefined ? JSON.stringify(result) : "[]",
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });

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

@@ -102,35 +102,12 @@ export const searchContactTool = {
                     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
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });

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

@@ -114,40 +114,16 @@ export const searchFileTool = {
                     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] ✅ File search completed successfully`);
                         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 {

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

@@ -102,38 +102,14 @@ export const searchMessageTool = {
                     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] ✅ Message search completed successfully`);
                         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),
                                 },
                             ],
                         });

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

@@ -21,19 +21,28 @@ export const searchNoteTool = {
         required: ["query"],
     },
     async execute(toolCallId, params) {
-        logger.debug("Executing search note tool, toolCallId:", toolCallId);
+        logger.log(`[SEARCH_NOTE_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_NOTE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_NOTE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.query) {
+            logger.error(`[SEARCH_NOTE_TOOL] ❌ Missing required parameter: query`);
             throw new Error("Missing required parameter: query is required");
         }
         // Get session context
+        logger.log(`[SEARCH_NOTE_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
+            logger.error(`[SEARCH_NOTE_TOOL] ❌ FAILED: No active session found!`);
             throw new Error("No active XY session found. Search note tool can only be used during an active conversation.");
         }
+        logger.log(`[SEARCH_NOTE_TOOL] ✅ Session context found`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
+        logger.log(`[SEARCH_NOTE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_NOTE_TOOL] ✅ WebSocket manager obtained`);
         // Build SearchNote command
         const command = {
             header: {
@@ -68,59 +77,57 @@ export const searchNoteTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_NOTE_TOOL] ⏳ Setting up promise to wait for note search response...`);
+        logger.log(`[SEARCH_NOTE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_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.debug("Received data event:", event);
+                logger.log(`[SEARCH_NOTE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "SearchNote") {
+                    logger.log(`[SEARCH_NOTE_TOOL] 🎯 SearchNote event received`);
+                    logger.log(`[SEARCH_NOTE_TOOL]   - status: ${event.status}`);
                     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}"`);
+                        logger.log(`[SEARCH_NOTE_TOOL] ✅ Note search completed successfully`);
+                        logger.log(`[SEARCH_NOTE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // 成功，直接返回完整的 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),
                                 },
                             ],
                         });
                     }
                     else {
+                        logger.error(`[SEARCH_NOTE_TOOL] ❌ Note search failed`);
+                        logger.error(`[SEARCH_NOTE_TOOL]   - status: ${event.status}`);
                         reject(new Error(`搜索备忘录失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
+            logger.log(`[SEARCH_NOTE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
+            logger.log(`[SEARCH_NOTE_TOOL] 📤 Sending SearchNote command...`);
             sendCommand({
                 config,
                 sessionId,
                 taskId,
                 messageId,
                 command,
+            }).then(() => {
+                logger.log(`[SEARCH_NOTE_TOOL] ✅ Command sent successfully, waiting for response...`);
             }).catch((error) => {
+                logger.error(`[SEARCH_NOTE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

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

@@ -91,33 +91,14 @@ export const searchPhotoGalleryTool = {
         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);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL] ✅ Photo search completed successfully`);
+        logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - outputs:`, JSON.stringify(outputs));
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({
-                        items,
-                        count: items.length,
-                        message: `找到 ${items.length} 张照片。注意：mediaUri 和 thumbnailUri 是本地路径，无法直接访问。如需下载或查看，请使用 upload_photo 工具。`
-                    }),
+                    text: JSON.stringify(outputs),
                 },
             ],
         };
@@ -125,7 +106,7 @@ 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...`);
@@ -177,10 +158,9 @@ async function searchPhotos(wsManager, config, sessionId, taskId, messageId, que
                 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);
+                    logger.log(`[SEARCH_PHOTO_GALLERY_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                    // 成功，直接返回完整的 event.outputs
+                    resolve(event.outputs);
                 }
                 else {
                     logger.error(`[SEARCH_PHOTO_GALLERY_TOOL] ❌ Photo search failed`);

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

@@ -128,30 +128,17 @@ export const sendMessageTool = {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEND_MESSAGE_TOOL] ✅ Send message response received`);
-                        logger.log(`[SEND_MESSAGE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
-                        // Check for error code in outputs
-                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
-                        if (code !== null && code !== 0) {
-                            logger.error(`[SEND_MESSAGE_TOOL] ❌ Device returned error`);
-                            logger.error(`[SEND_MESSAGE_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[SEND_MESSAGE_TOOL]   - errorMsg: ${errorMsg}`);
-                            reject(new Error(`发送短信失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
-                        // Extract result with safe checks
-                        const result = event.outputs.result || {};
-                        logger.log(`[SEND_MESSAGE_TOOL] 🎉 Message sent successfully`);
+                        logger.log(`[SEND_MESSAGE_TOOL] ✅ Message sent successfully`);
                         logger.log(`[SEND_MESSAGE_TOOL]   - phoneNumber: ${phoneNumber}`);
-                        logger.log(`[SEND_MESSAGE_TOOL]   - result:`, JSON.stringify(result));
+                        logger.log(`[SEND_MESSAGE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
-                                },
-                            ],
+                                    text: JSON.stringify(event.outputs),
+                                }
+                            ]
                         });
                     }
                     else {

package/package.json

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