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

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY delete alarm tool - deletes existing alarms on user's device.
  * Requires entityId(s) from search_alarm or create_alarm tool as prerequisite.
@@ -27,7 +26,9 @@ export const deleteAlarmTool = {
 注意事项：
 1. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
 2. 删除操作不可撤销，请确认 entityId 正确后再删除。
-3. items 参数支持数组或 JSON 字符串格式，代码会自动解析。`,
+3. items 参数支持数组或 JSON 字符串格式，代码会自动解析。
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
     parameters: {
         type: "object",
         properties: {
@@ -40,85 +41,57 @@ export const deleteAlarmTool = {
         required: ["items"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[DELETE_ALARM_TOOL] 🚀 Starting execution`);
-        logger.log(`[DELETE_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[DELETE_ALARM_TOOL]   - params (raw):`, JSON.stringify(params));
-        logger.log(`[DELETE_ALARM_TOOL]   - params.items type:`, typeof params.items);
-        logger.log(`[DELETE_ALARM_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // ===== 参数规范化：兼容数组和 JSON 字符串 =====
         let items = null;
         if (!params.items) {
-            logger.error(`[DELETE_ALARM_TOOL] ❌ Missing parameter: items`);
             throw new Error("Missing required parameter: items");
         }
         // 情况1: 已经是数组
         if (Array.isArray(params.items)) {
-            logger.log(`[DELETE_ALARM_TOOL] ✅ items is already an array`);
             items = params.items;
         }
         // 情况2: 是字符串，尝试解析为 JSON 数组
         else if (typeof params.items === 'string') {
-            logger.log(`[DELETE_ALARM_TOOL] 🔄 items is a string, attempting to parse as JSON...`);
             try {
                 const parsed = JSON.parse(params.items);
                 if (Array.isArray(parsed)) {
-                    logger.log(`[DELETE_ALARM_TOOL] ✅ Successfully parsed JSON string to array`);
                     items = parsed;
                 }
                 else {
-                    logger.error(`[DELETE_ALARM_TOOL] ❌ Parsed JSON is not an array:`, typeof parsed);
                     throw new Error("items must be an array or a JSON string representing an array");
                 }
             }
             catch (parseError) {
-                logger.error(`[DELETE_ALARM_TOOL] ❌ Failed to parse items as JSON:`, parseError);
                 throw new Error(`items must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
             }
         }
         // 情况3: 其他类型，报错
         else {
-            logger.error(`[DELETE_ALARM_TOOL] ❌ Invalid items type:`, typeof params.items);
             throw new Error(`items must be an array or a JSON string, got ${typeof params.items}`);
         }
         // 验证数组非空
         if (!items || items.length === 0) {
-            logger.error(`[DELETE_ALARM_TOOL] ❌ items array is empty`);
             throw new Error("items array cannot be empty");
         }
-        logger.log(`[DELETE_ALARM_TOOL] ✅ Normalized items:`, JSON.stringify(items));
         // 验证每个 item 是否有有效的 entityId
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
             if (!item || typeof item !== 'object') {
-                logger.error(`[DELETE_ALARM_TOOL] ❌ Item at index ${i} is not an object`);
                 throw new Error(`items[${i}] must be an object with entityId property`);
             }
             if (!item.entityId || typeof item.entityId !== 'string') {
-                logger.error(`[DELETE_ALARM_TOOL] ❌ Item at index ${i} missing or invalid entityId`);
                 throw new Error(`items[${i}] must have a valid entityId string property`);
             }
         }
-        logger.log(`[DELETE_ALARM_TOOL]   - items count: ${items.length}`);
-        logger.log(`[DELETE_ALARM_TOOL]   - entityIds:`, items.map(item => item.entityId).join(", "));
         // Get session context
-        logger.log(`[DELETE_ALARM_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[DELETE_ALARM_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[DELETE_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Delete alarm tool can only be used during an active conversation.");
         }
-        logger.log(`[DELETE_ALARM_TOOL] ✅ Session context found`);
-        logger.log(`[DELETE_ALARM_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[DELETE_ALARM_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[DELETE_ALARM_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[DELETE_ALARM_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[DELETE_ALARM_TOOL] ✅ WebSocket manager obtained`);
         // Build DeleteAlarm command
-        logger.log(`[DELETE_ALARM_TOOL] 📦 Building DeleteAlarm command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -153,70 +126,35 @@ export const deleteAlarmTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[DELETE_ALARM_TOOL] ⏳ Setting up promise to wait for alarm deletion response...`);
-        logger.log(`[DELETE_ALARM_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[DELETE_ALARM_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(`[DELETE_ALARM_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "DeleteAlarm") {
-                    logger.log(`[DELETE_ALARM_TOOL] 🎯 DeleteAlarm event received`);
-                    logger.log(`[DELETE_ALARM_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     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;
-                        }
-                        // Extract result with safe navigation
-                        const result = event.outputs.result || {};
-                        logger.log(`[DELETE_ALARM_TOOL] 📋 Deletion result:`, JSON.stringify(result));
-                        // Build response with safe navigation
-                        const response = {
-                            success: true,
-                            entityName: result.entityName || "Alarm",
-                            message: result.message || "Alarm deleted successfully",
-                            deletedCount: items.length,
-                        };
-                        // Add entityIds from request for reference
-                        response.deletedIds = items.map(item => item.entityId);
-                        logger.log(`[DELETE_ALARM_TOOL] 🎉 Successfully deleted ${items.length} alarm(s)`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(response),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
                     }
                     else {
-                        logger.error(`[DELETE_ALARM_TOOL] ❌ Alarm deletion failed`);
-                        logger.error(`[DELETE_ALARM_TOOL]   - status: ${event.status}`);
-                        logger.error(`[DELETE_ALARM_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
                         reject(new Error(`删除闹钟失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[DELETE_ALARM_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[DELETE_ALARM_TOOL] 📤 Sending DeleteAlarm command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -225,10 +163,8 @@ export const deleteAlarmTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[DELETE_ALARM_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[DELETE_ALARM_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/device-tool-map.d.ts

@@ -0,0 +1,4 @@
+/** Known device type enum. */
+export declare const DEVICE_TYPES: readonly ["car", "pc", "phone"];
+export type DeviceType = (typeof DEVICE_TYPES)[number];
+export declare function filterToolsByDevice(tools: any[], deviceType?: string): any[];

package/dist/src/tools/device-tool-map.js

@@ -0,0 +1,24 @@
+// Device type to tool name mapping.
+// Only tools listed under a device type are available for that device.
+// Tools NOT listed here are available to ALL devices (no restriction).
+/** Known device type enum. */
+export const DEVICE_TYPES = ["car", "pc", "phone"];
+/**
+ * Map: deviceType → tool names allowed for that device.
+ * undefined / empty deviceType → all tools available.
+ * Unrecognized deviceType → all tools available.
+ * Tool not listed in any device entry → available to all devices.
+ */
+const DEVICE_TOOL_ALLOWLIST = {
+    car: ["send_command_to_car"],
+    pc: ["location"],
+    phone: ["location"],
+};
+export function filterToolsByDevice(tools, deviceType) {
+    if (!deviceType)
+        return tools;
+    const allowedTools = DEVICE_TOOL_ALLOWLIST[deviceType];
+    if (!allowedTools)
+        return tools; // unrecognized device → no filtering
+    return tools.filter((tool) => allowedTools.includes(tool.name));
+}

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,328 @@
+// Image Reading tool implementation
+import { XYFileUploadService } from "../file-upload.js";
+import { getCurrentSessionContext } from "./session-manager.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) {
+    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);
+        return localPath;
+    }
+    catch (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) {
+    // Check if it's a remote URL
+    if (isRemoteUrl(imageInput)) {
+        const localPath = await downloadRemoteFile(imageInput);
+        const imageUrl = await uploadService.uploadFileAndGetUrl(localPath, "TEMPORARY_MATERIAL_DOC");
+        if (!imageUrl) {
+            throw new Error("图片上传失败：无法获取图片访问地址");
+        }
+        return { imageUrl, localPath };
+    }
+    // Check if it's a local file
+    const isLocal = await isLocalFile(imageInput);
+    if (isLocal) {
+        const imageUrl = await uploadService.uploadFileAndGetUrl(imageInput, "TEMPORARY_MATERIAL_DOC");
+        if (!imageUrl) {
+            throw new Error("图片上传失败：无法获取图片访问地址");
+        }
+        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, fileUploadUrl) {
+    const apiUrl = `${fileUploadUrl}/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 },
+                },
+            },
+        ],
+    };
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            // @ts-ignore - node-fetch supports this
+            timeout: 120000, // 2 minutes timeout
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+        }
+        // Process SSE stream
+        let lastCaption = "";
+        let lineCount = 0;
+        let buffer = "";
+        // 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;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (parseError) {
+                        }
+                    }
+                }
+            }
+        }
+        if (!lastCaption) {
+            throw new Error("No caption received from image understanding API");
+        }
+        return lastCaption;
+    }
+    catch (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) {
+        // Validate that at least one parameter is provided
+        if (!params.localUrl && !params.remoteUrl) {
+            throw new Error("At least one of localUrl or remoteUrl must be provided");
+        }
+        // Get prompt (default to "描述这张图片内容")
+        const prompt = params.prompt || "描述这张图片内容";
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Image reading tool can only be used during an active conversation.");
+        }
+        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;
+            processedImage = await processImageInput(imageInput, uploadService);
+            // Track downloaded file for cleanup
+            if (processedImage.localPath) {
+                downloadedFile = processedImage.localPath;
+            }
+            // Call image understanding API
+            const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid, config.fileUploadUrl);
+            // Clean up downloaded file if any
+            if (downloadedFile) {
+                try {
+                    await fs.unlink(downloadedFile);
+                }
+                catch (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) {
+                try {
+                    await fs.unlink(downloadedFile);
+                }
+                catch (cleanupError) {
+                }
+            }
+            const errorMessage = error instanceof Error ? error.message : "图片分析失败";
+            // Return error result instead of throwing
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: errorMessage,
+                            prompt,
+                            imageSource: params.localUrl ? "local" : "remote",
+                            success: false,
+                        }),
+                    },
+                ],
+            };
+        }
+    },
+};

package/dist/src/tools/location-tool.js

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY location tool - gets user's current location.
  * Returns WGS84 coordinates (latitude, longitude).
@@ -9,38 +8,22 @@ import { logger } from "../utils/logger.js";
 export const locationTool = {
     name: "get_user_location",
     label: "Get User Location",
-    description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {},
         required: [],
     },
     async execute(toolCallId, params) {
-        logger.log(`[LOCATION_TOOL] 🚀 Starting execution`);
-        logger.log(`[LOCATION_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[LOCATION_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[LOCATION_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Get session context
-        logger.log(`[LOCATION_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[LOCATION_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[LOCATION_TOOL]   - toolCallId: ${toolCallId}`);
-            logger.error(`[LOCATION_TOOL]   - This suggests the session was not registered or already cleaned up`);
             throw new Error("No active XY session found. Location tool can only be used during an active conversation.");
         }
-        logger.log(`[LOCATION_TOOL] ✅ Session context found`);
-        logger.log(`[LOCATION_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[LOCATION_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[LOCATION_TOOL]   - messageId: ${sessionContext.messageId}`);
-        logger.log(`[LOCATION_TOOL]   - agentId: ${sessionContext.agentId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[LOCATION_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[LOCATION_TOOL] ✅ WebSocket manager obtained`);
         // Build GetCurrentLocation command
-        logger.log(`[LOCATION_TOOL] 📦 Building GetCurrentLocation command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -55,7 +38,9 @@ export const locationTool = {
                     dimension: "",
                     executeMode: "background",
                     intentName: "GetCurrentLocation",
-                    intentParam: {},
+                    intentParam: {
+                        isNeedGeoAddress: true,
+                    },
                     needUnlock: true,
                     permissionId: [],
                     timeOut: 5,
@@ -70,53 +55,36 @@ export const locationTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[LOCATION_TOOL] ⏳ Setting up promise to wait for location response...`);
-        logger.log(`[LOCATION_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[LOCATION_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(`[LOCATION_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "GetCurrentLocation") {
-                    logger.log(`[LOCATION_TOOL] 🎯 GetCurrentLocation event received`);
-                    logger.log(`[LOCATION_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        const { latitude, longitude } = event.outputs;
-                        logger.log(`[LOCATION_TOOL] ✅ Location retrieved successfully`);
-                        logger.log(`[LOCATION_TOOL]   - latitude: ${latitude}`);
-                        logger.log(`[LOCATION_TOOL]   - longitude: ${longitude}`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify({
-                                        latitude,
-                                        longitude,
-                                        coordinateSystem: "WGS84",
-                                    })
+                                    text: JSON.stringify(event.outputs),
                                 }
                             ]
                         });
                     }
                     else {
-                        logger.error(`[LOCATION_TOOL] ❌ Location retrieval failed`);
-                        logger.error(`[LOCATION_TOOL]   - status: ${event.status}`);
                         reject(new Error(`获取位置失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
             // Note: The WebSocket manager needs to emit 'data-event' when receiving data events
-            logger.log(`[LOCATION_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[LOCATION_TOOL] 📤 Sending GetCurrentLocation command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -124,9 +92,7 @@ export const locationTool = {
                 messageId,
                 command,
             }).then(() => {
-                logger.log(`[LOCATION_TOOL] ✅ Command sent successfully, waiting for response...`);
             }).catch((error) => {
-                logger.error(`[LOCATION_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);