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

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY modify note tool - appends content to an existing note on user's device.
  * Requires entityId from search_notes tool as prerequisite.
@@ -13,7 +12,7 @@ import { logger } from "../utils/logger.js";
 export const modifyNoteTool = {
     name: "modify_note",
     label: "Modify Note",
-    description: "在指定备忘录中追加新内容。使用前必须先调用 search_notes 工具获取备忘录的 entityId。参数说明：entityId 是备忘录的唯一标识符（从 search_notes 工具获取），text 是要追加的文本内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "在指定备忘录中追加新内容。使用前必须先调用 search_notes 工具获取备忘录的 entityId。参数说明：entityId 是备忘录的唯一标识符（从 search_notes 工具获取），text 是要追加的文本内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -29,34 +28,19 @@ export const modifyNoteTool = {
         required: ["entityId", "text"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[MODIFY_NOTE_TOOL] 🚀 Starting execution`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[MODIFY_NOTE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.entityId || !params.text) {
-            logger.error(`[MODIFY_NOTE_TOOL] ❌ Missing required parameters`);
             throw new Error("Missing required parameters: entityId and text are required");
         }
         // Get session context
-        logger.log(`[MODIFY_NOTE_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[MODIFY_NOTE_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Modify note tool can only be used during an active conversation.");
         }
-        logger.log(`[MODIFY_NOTE_TOOL] ✅ Session context found`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[MODIFY_NOTE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[MODIFY_NOTE_TOOL] ✅ WebSocket manager obtained`);
         // Build ModifyNote command
-        logger.log(`[MODIFY_NOTE_TOOL] 📦 Building ModifyNote command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -92,29 +76,18 @@ export const modifyNoteTool = {
                 pageControlRelated: false,
             },
         };
-        logger.log(`[MODIFY_NOTE_TOOL]   - entityId: ${params.entityId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - contentType: 1 (append mode)`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - text length: ${params.text.length} characters`);
         // Send command and wait for response (60 second timeout)
-        logger.log(`[MODIFY_NOTE_TOOL] ⏳ Setting up promise to wait for note modification response...`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[MODIFY_NOTE_TOOL] ⏰ Timeout: No response received within 60 seconds`);
                 wsManager.off("data-event", handler);
                 reject(new Error("修改备忘录超时（60秒）"));
             }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.log(`[MODIFY_NOTE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "ModifyNote") {
-                    logger.log(`[MODIFY_NOTE_TOOL] 🎯 ModifyNote event received`);
-                    logger.log(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[MODIFY_NOTE_TOOL] ✅ Note modified successfully`);
-                        logger.log(`[MODIFY_NOTE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -126,17 +99,13 @@ export const modifyNoteTool = {
                         });
                     }
                     else {
-                        logger.error(`[MODIFY_NOTE_TOOL] ❌ Note modification failed`);
-                        logger.error(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
                         reject(new Error(`修改备忘录失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[MODIFY_NOTE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[MODIFY_NOTE_TOOL] 📤 Sending ModifyNote command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -145,10 +114,8 @@ export const modifyNoteTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[MODIFY_NOTE_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[MODIFY_NOTE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * Duck-typed ToolInputError: openclaw 按 .name 字段匹配，不用 instanceof。
  * 抛出此错误会让 openclaw 返回 HTTP 400 而非 500，
@@ -26,6 +25,8 @@ export const noteTool = {
   a. 操作超时时间为60秒,请勿重复调用此工具
   b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
   c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
     parameters: {
         type: "object",
@@ -42,7 +43,6 @@ export const noteTool = {
         required: ["title", "content"],
     },
     async execute(toolCallId, params) {
-        logger.debug("Executing note tool, toolCallId:", toolCallId);
         // Validate parameters — 抛 ToolInputError 而非普通 Error，
         // 让 openclaw 返回 400 而非 500，明确告知 LLM 这是参数错误，不应重试。
         if (typeof params.title !== "string" || !params.title) {
@@ -101,12 +101,10 @@ export const noteTool = {
             }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.debug("Received data event:", event);
                 if (event.intentName === "CreateNote") {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`Note created successfully, outputs:`, JSON.stringify(event.outputs));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [

package/dist/src/tools/search-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";
 // Enum definitions for alarm search parameters
 const RANGE_TYPE_VALUES = ["all", "next", "current"];
 const ALARM_STATE_VALUES = [0, 1];
@@ -33,7 +32,9 @@ export const searchAlarmTool = {
 
 注意：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
-b. 使用该工具之前需获取当前真实时间`,
+b. 使用该工具之前需获取当前真实时间
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
     parameters: {
         type: "object",
         properties: {
@@ -63,10 +64,6 @@ b. 使用该工具之前需获取当前真实时间`,
         },
     },
     async execute(toolCallId, params) {
-        logger.log(`[SEARCH_ALARM_TOOL] 🚀 Starting execution`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[SEARCH_ALARM_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // ===== Validate at least one search criterion is provided =====
         const hasRangeType = params.rangeType !== undefined && params.rangeType !== null;
         const hasAlarmState = params.alarmState !== undefined && params.alarmState !== null;
@@ -74,92 +71,64 @@ b. 使用该工具之前需获取当前真实时间`,
         const hasStartTime = params.startTime !== undefined && params.startTime !== null;
         const hasEndTime = params.endTime !== undefined && params.endTime !== null;
         if (!hasRangeType && !hasAlarmState && !hasDaysOfWakeType && !hasStartTime && !hasEndTime) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ No search criteria provided`);
             throw new Error("至少需要提供一个检索条件：rangeType、alarmState、daysOfWakeType 或时间范围（startTime + endTime）");
         }
         // ===== Validate rangeType =====
         if (hasRangeType) {
             if (typeof params.rangeType !== "string") {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid rangeType type`);
                 throw new Error("rangeType must be a string");
             }
             if (!RANGE_TYPE_VALUES.includes(params.rangeType)) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid rangeType value: ${params.rangeType}`);
                 throw new Error(`rangeType must be one of: ${RANGE_TYPE_VALUES.join(", ")}`);
             }
-            logger.log(`[SEARCH_ALARM_TOOL]   - rangeType: ${params.rangeType}`);
         }
         // ===== Validate alarmState =====
         if (hasAlarmState) {
             if (typeof params.alarmState !== "number") {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid alarmState type`);
                 throw new Error("alarmState must be a number");
             }
             if (!ALARM_STATE_VALUES.includes(params.alarmState)) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid alarmState value: ${params.alarmState}`);
                 throw new Error(`alarmState must be one of: ${ALARM_STATE_VALUES.join(", ")}`);
             }
-            logger.log(`[SEARCH_ALARM_TOOL]   - alarmState: ${params.alarmState}`);
         }
         // ===== Validate daysOfWakeType =====
         if (hasDaysOfWakeType) {
             if (typeof params.daysOfWakeType !== "number") {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid daysOfWakeType type`);
                 throw new Error("daysOfWakeType must be a number");
             }
             if (!DAYS_OF_WAKE_TYPE_VALUES.includes(params.daysOfWakeType)) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid daysOfWakeType value: ${params.daysOfWakeType}`);
                 throw new Error(`daysOfWakeType must be one of: ${DAYS_OF_WAKE_TYPE_VALUES.join(", ")}`);
             }
-            logger.log(`[SEARCH_ALARM_TOOL]   - daysOfWakeType: ${params.daysOfWakeType}`);
         }
         // ===== Validate time interval (startTime and endTime must be provided together) =====
         if (hasStartTime !== hasEndTime) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ startTime and endTime must be provided together`);
             throw new Error("startTime 和 endTime 必须一起提供");
         }
         let timeInterval = null;
         if (hasStartTime && hasEndTime) {
             // Parse and convert startTime and endTime to timestamps
-            logger.log(`[SEARCH_ALARM_TOOL] 🕒 Parsing time interval...`);
-            logger.log(`[SEARCH_ALARM_TOOL]   - startTime input: ${params.startTime}`);
-            logger.log(`[SEARCH_ALARM_TOOL]   - endTime input: ${params.endTime}`);
             const startTimeMs = parseAlarmTimeToTimestamp(params.startTime);
             const endTimeMs = parseAlarmTimeToTimestamp(params.endTime);
             if (startTimeMs === null) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid startTime format`);
                 throw new Error("Invalid startTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 000000)");
             }
             if (endTimeMs === null) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid endTime format`);
                 throw new Error("Invalid endTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 235959)");
             }
             if (startTimeMs >= endTimeMs) {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ startTime must be before endTime`);
                 throw new Error("startTime 必须早于 endTime");
             }
             timeInterval = [startTimeMs, endTimeMs];
-            logger.log(`[SEARCH_ALARM_TOOL] ✅ Time interval parsed: [${startTimeMs}, ${endTimeMs}]`);
         }
         // Get session context
-        logger.log(`[SEARCH_ALARM_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[SEARCH_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Search alarm tool can only be used during an active conversation.");
         }
-        logger.log(`[SEARCH_ALARM_TOOL] ✅ Session context found`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[SEARCH_ALARM_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[SEARCH_ALARM_TOOL] ✅ WebSocket manager obtained`);
         // Build SearchAlarm command
-        logger.log(`[SEARCH_ALARM_TOOL] 📦 Building SearchAlarm command...`);
         // Build intentParam with provided search criteria
         const intentParam = {};
         if (hasRangeType) {
@@ -206,25 +175,17 @@ b. 使用该工具之前需获取当前真实时间`,
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[SEARCH_ALARM_TOOL] ⏳ Setting up promise to wait for alarm search response...`);
-        logger.log(`[SEARCH_ALARM_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[SEARCH_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(`[SEARCH_ALARM_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "SearchAlarm") {
-                    logger.log(`[SEARCH_ALARM_TOOL] 🎯 SearchAlarm event received`);
-                    logger.log(`[SEARCH_ALARM_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     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));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -236,18 +197,13 @@ b. 使用该工具之前需获取当前真实时间`,
                         });
                     }
                     else {
-                        logger.error(`[SEARCH_ALARM_TOOL] ❌ Alarm search failed`);
-                        logger.error(`[SEARCH_ALARM_TOOL]   - status: ${event.status}`);
-                        logger.error(`[SEARCH_ALARM_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
                         reject(new Error(`检索闹钟失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[SEARCH_ALARM_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[SEARCH_ALARM_TOOL] 📤 Sending SearchAlarm command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -256,10 +212,8 @@ b. 使用该工具之前需获取当前真实时间`,
                 command,
             })
                 .then(() => {
-                logger.log(`[SEARCH_ALARM_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[SEARCH_ALARM_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);
@@ -279,17 +233,14 @@ function parseAlarmTimeToTimestamp(alarmTime) {
         const trimmed = alarmTime.trim();
         // Check basic format (should have at least 13 characters: YYYYMMDD hhmmss)
         if (trimmed.length < 13) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ alarmTime too short: ${trimmed}`);
             return null;
         }
         // Extract date and time parts
         // Format: YYYYMMDD hhmmss
         const datePart = trimmed.substring(0, 8); // YYYYMMDD
         const timePart = trimmed.substring(8).trim(); // hhmmss (may have leading space)
-        logger.log(`[SEARCH_ALARM_TOOL]   - datePart: ${datePart}, timePart: ${timePart}`);
         // Validate lengths
         if (datePart.length !== 8 || timePart.length !== 6) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid part lengths: datePart=${datePart.length}, timePart=${timePart.length}`);
             return null;
         }
         // Parse components
@@ -299,45 +250,36 @@ function parseAlarmTimeToTimestamp(alarmTime) {
         const hour = parseInt(timePart.substring(0, 2), 10);
         const minute = parseInt(timePart.substring(2, 4), 10);
         const second = parseInt(timePart.substring(4, 6), 10);
-        logger.log(`[SEARCH_ALARM_TOOL]   - Parsed: ${year}-${month}-${day} ${hour}:${minute}:${second}`);
         // Validate values
         if (isNaN(year) || isNaN(month) || isNaN(day) ||
             isNaN(hour) || isNaN(minute) || isNaN(second)) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ NaN detected in parsed values`);
             return null;
         }
         // Validate ranges
         if (month < 1 || month > 12) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid month: ${month}`);
             return null;
         }
         if (day < 1 || day > 31) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid day: ${day}`);
             return null;
         }
         if (hour < 0 || hour > 23) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid hour: ${hour}`);
             return null;
         }
         if (minute < 0 || minute > 59) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid minute: ${minute}`);
             return null;
         }
         if (second < 0 || second > 59) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Invalid second: ${second}`);
             return null;
         }
         // Create Date object and get timestamp
         const date = new Date(year, month - 1, day, hour, minute, second);
         const timestamp = date.getTime();
         if (isNaN(timestamp)) {
-            logger.error(`[SEARCH_ALARM_TOOL] ❌ Generated timestamp is NaN`);
             return null;
         }
         return timestamp;
     }
     catch (error) {
-        logger.error(`[SEARCH_ALARM_TOOL] ❌ Exception in parseAlarmTimeToTimestamp:`, error);
         return null;
     }
 }

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY search calendar event tool - searches calendar events on user's device.
  * Returns matching events based on time range and optional title filter.
@@ -28,6 +27,8 @@ export const searchCalendarTool = {
 注意：
 a. 该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
 b. 使用该工具之前需获取当前真实时间
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
 `,
     parameters: {
         type: "object",
@@ -48,19 +49,11 @@ b. 使用该工具之前需获取当前真实时间
         required: ["startTime", "endTime"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[SEARCH_CALENDAR_TOOL] 🚀 Starting execution`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.startTime || !params.endTime) {
-            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Missing required parameters`);
             throw new Error("Missing required parameters: startTime and endTime are required");
         }
         // Convert time strings to millisecond timestamps
-        logger.log(`[SEARCH_CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime input: ${params.startTime}`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime input: ${params.endTime}`);
         // Parse YYYYMMDD hhmmss format
         const parseTimeString = (timeStr) => {
             // Remove any extra spaces and split
@@ -90,42 +83,26 @@ b. 使用该工具之前需获取当前真实时间
             endTimeMs = parseTimeString(params.endTime);
         }
         catch (error) {
-            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Time parsing error:`, error);
             throw new Error(`Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000). Error: ${error instanceof Error ? error.message : String(error)}`);
         }
         if (isNaN(startTimeMs) || isNaN(endTimeMs)) {
-            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Invalid time format`);
             throw new Error("Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000)");
         }
-        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Time conversion successful`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime timestamp: ${startTimeMs}`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime timestamp: ${endTimeMs}`);
         // Get session context
-        logger.log(`[SEARCH_CALENDAR_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Search calendar tool can only be used during an active conversation.");
         }
-        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Session context found`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[SEARCH_CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ WebSocket manager obtained`);
         // Build SearchCalendarEvent command
-        logger.log(`[SEARCH_CALENDAR_TOOL] 📦 Building SearchCalendarEvent command...`);
         // Build intentParam with timeInterval and optional title
         const intentParam = {
             timeInterval: [startTimeMs, endTimeMs],
         };
         if (params.title) {
             intentParam.title = params.title;
-            logger.log(`[SEARCH_CALENDAR_TOOL]   - Including title filter: ${params.title}`);
         }
         const command = {
             header: {
@@ -160,25 +137,17 @@ b. 使用该工具之前需获取当前真实时间
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[SEARCH_CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar search response...`);
-        logger.log(`[SEARCH_CALENDAR_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[SEARCH_CALENDAR_TOOL] ⏰ Timeout: No response received within 60 seconds`);
                 wsManager.off("data-event", handler);
                 reject(new Error("检索日程超时（60秒）"));
             }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.log(`[SEARCH_CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "SearchCalendarEvent") {
-                    logger.log(`[SEARCH_CALENDAR_TOOL] 🎯 SearchCalendarEvent event received`);
-                    logger.log(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events retrieved successfully`);
-                        logger.log(`[SEARCH_CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -190,17 +159,13 @@ b. 使用该工具之前需获取当前真实时间
                         });
                     }
                     else {
-                        logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Calendar event search failed`);
-                        logger.error(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
                         reject(new Error(`检索日程失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[SEARCH_CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[SEARCH_CALENDAR_TOOL] 📤 Sending SearchCalendarEvent command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -209,10 +174,8 @@ b. 使用该工具之前需获取当前真实时间
                 command,
             })
                 .then(() => {
-                logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY search contact tool - searches contacts on user's device.
  * Returns matching contact information based on name.
@@ -21,34 +20,19 @@ export const searchContactTool = {
         required: ["name"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[SEARCH_CONTACT_TOOL] 🚀 Starting execution`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[SEARCH_CONTACT_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.name) {
-            logger.error(`[SEARCH_CONTACT_TOOL] ❌ Missing required parameter: name`);
             throw new Error("Missing required parameter: name is required");
         }
         // Get session context
-        logger.log(`[SEARCH_CONTACT_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[SEARCH_CONTACT_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[SEARCH_CONTACT_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Search contact tool can only be used during an active conversation.");
         }
-        logger.log(`[SEARCH_CONTACT_TOOL] ✅ Session context found`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[SEARCH_CONTACT_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[SEARCH_CONTACT_TOOL] ✅ WebSocket manager obtained`);
         // Build SearchContactLocal command
-        logger.log(`[SEARCH_CONTACT_TOOL] 📦 Building SearchContactLocal command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -83,25 +67,17 @@ export const searchContactTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[SEARCH_CONTACT_TOOL] ⏳ Setting up promise to wait for contact search response...`);
-        logger.log(`[SEARCH_CONTACT_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[SEARCH_CONTACT_TOOL] ⏰ Timeout: No response received within 60 seconds`);
                 wsManager.off("data-event", handler);
                 reject(new Error("搜索联系人超时（60秒）"));
             }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.log(`[SEARCH_CONTACT_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "SearchContactLocal") {
-                    logger.log(`[SEARCH_CONTACT_TOOL] 🎯 SearchContactLocal event received`);
-                    logger.log(`[SEARCH_CONTACT_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEARCH_CONTACT_TOOL] ✅ Contact search completed successfully`);
-                        logger.log(`[SEARCH_CONTACT_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -113,17 +89,13 @@ export const searchContactTool = {
                         });
                     }
                     else {
-                        logger.error(`[SEARCH_CONTACT_TOOL] ❌ Contact search failed`);
-                        logger.error(`[SEARCH_CONTACT_TOOL]   - status: ${event.status}`);
                         reject(new Error(`搜索联系人失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[SEARCH_CONTACT_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[SEARCH_CONTACT_TOOL] 📤 Sending SearchContactLocal command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -132,10 +104,8 @@ export const searchContactTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[SEARCH_CONTACT_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[SEARCH_CONTACT_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);