@ynhcj/xiaoyi-channel 0.0.50-beta → 0.0.52-beta

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,25 +126,17 @@ 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));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -183,18 +148,13 @@ export const deleteAlarmTool = {
                         });
                     }
                     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,
@@ -203,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/image-reading-tool.js

@@ -1,7 +1,6 @@
 // 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";
@@ -34,7 +33,6 @@ async function isLocalFile(value) {
  * 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) {
@@ -56,11 +54,9 @@ async function downloadRemoteFile(url) {
         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)}`);
     }
 }
@@ -68,30 +64,22 @@ async function downloadRemoteFile(url) {
  * 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");
         if (!imageUrl) {
-            logger.error(`[IMAGE_READING_TOOL] ❌ Failed to get URL after upload`);
             throw new Error("图片上传失败：无法获取图片访问地址");
         }
-        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");
         if (!imageUrl) {
-            logger.error(`[IMAGE_READING_TOOL] ❌ Failed to get URL after upload`);
             throw new Error("图片上传失败：无法获取图片访问地址");
         }
-        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}`);
@@ -100,9 +88,6 @@ async function processImageInput(imageInput, uploadService) {
  * 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 = {
@@ -149,7 +134,6 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid) {
             },
         ],
     };
-    logger.log(`[IMAGE_READING_TOOL] 📡 Sending request with trace ID: ${traceId}`);
     try {
         const response = await fetch(apiUrl, {
             method: "POST",
@@ -158,19 +142,14 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid) {
             // @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");
@@ -198,29 +177,23 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid) {
                                         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;
     }
 }
@@ -278,26 +251,17 @@ d. 返回图像理解的文本描述内容`,
         },
     },
     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);
@@ -306,27 +270,19 @@ d. 返回图像理解的文本描述内容`,
         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 {
@@ -346,15 +302,12 @@ d. 返回图像理解的文本描述内容`,
         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);
             const errorMessage = error instanceof Error ? error.message : "图片分析失败";
             // Return error result instead of throwing
             return {

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",
@@ -72,25 +55,17 @@ 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) {
-                        logger.log(`[LOCATION_TOOL] ✅ Location retrieved successfully`);
-                        logger.log(`[LOCATION_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -102,18 +77,14 @@ export const locationTool = {
                         });
                     }
                     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,
@@ -121,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);