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

package/dist/src/tools/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 calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
@@ -12,6 +11,8 @@ export const calendarTool = {
     label: "Create Calendar Event",
     description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
   注意事项：使用该工具之前需获取当前真实时间
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
     parameters: {
         type: "object",
@@ -32,47 +33,25 @@ export const calendarTool = {
         required: ["title", "dtStart", "dtEnd"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[CALENDAR_TOOL] 🚀 Starting execution`);
-        logger.log(`[CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[CALENDAR_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.title || !params.dtStart || !params.dtEnd) {
-            logger.error(`[CALENDAR_TOOL] ❌ Missing required parameters`);
             throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
         }
         // Convert time strings to millisecond timestamps
-        logger.log(`[CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
-        logger.log(`[CALENDAR_TOOL]   - dtStart input: ${params.dtStart}`);
-        logger.log(`[CALENDAR_TOOL]   - dtEnd input: ${params.dtEnd}`);
         const dtStartMs = new Date(params.dtStart).getTime();
         const dtEndMs = new Date(params.dtEnd).getTime();
         if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
-            logger.error(`[CALENDAR_TOOL] ❌ Invalid time format`);
             throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
         }
-        logger.log(`[CALENDAR_TOOL] ✅ Time conversion successful`);
-        logger.log(`[CALENDAR_TOOL]   - dtStart timestamp: ${dtStartMs}`);
-        logger.log(`[CALENDAR_TOOL]   - dtEnd timestamp: ${dtEndMs}`);
         // Get session context
-        logger.log(`[CALENDAR_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[CALENDAR_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Calendar tool can only be used during an active conversation.");
         }
-        logger.log(`[CALENDAR_TOOL] ✅ Session context found`);
-        logger.log(`[CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[CALENDAR_TOOL] ✅ WebSocket manager obtained`);
         // Build CreateCalendarEvent command
-        logger.log(`[CALENDAR_TOOL] 📦 Building CreateCalendarEvent command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -108,25 +87,17 @@ export const calendarTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar event response...`);
-        logger.log(`[CALENDAR_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[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(`[CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "CreateCalendarEvent") {
-                    logger.log(`[CALENDAR_TOOL] 🎯 CreateCalendarEvent event received`);
-                    logger.log(`[CALENDAR_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[CALENDAR_TOOL] ✅ Calendar event created successfully`);
-                        logger.log(`[CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         resolve({
                             content: [
                                 {
@@ -137,17 +108,13 @@ export const calendarTool = {
                         });
                     }
                     else {
-                        logger.error(`[CALENDAR_TOOL] ❌ Calendar event creation failed`);
-                        logger.error(`[CALENDAR_TOOL]   - status: ${event.status}`);
                         reject(new Error(`创建日程失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[CALENDAR_TOOL] 📤 Sending CreateCalendarEvent command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -156,10 +123,8 @@ export const calendarTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[CALENDAR_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/call-phone-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 call phone tool - makes a phone call on user's device.
  * Requires phoneNumber parameter and optional slotId (0 for primary SIM, 1 for secondary SIM).
@@ -9,7 +8,7 @@ import { logger } from "../utils/logger.js";
 export const callPhoneTool = {
     name: "call_phone",
     label: "Call Phone",
-    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -26,43 +25,25 @@ export const callPhoneTool = {
         required: ["phoneNumber"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[CALL_PHONE_TOOL] 🚀 Starting execution`);
-        logger.log(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[CALL_PHONE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate phoneNumber parameter
         if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
-            logger.error(`[CALL_PHONE_TOOL] ❌ Missing or invalid phoneNumber parameter`);
             throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
         }
         // Set default slotId if not provided
         const slotId = params.slotId !== undefined && params.slotId !== null ? params.slotId : 0;
         // Validate slotId (must be 0 or 1)
         if (slotId !== 0 && slotId !== 1) {
-            logger.error(`[CALL_PHONE_TOOL] ❌ Invalid slotId: ${slotId}`);
             throw new Error("Invalid slotId: must be 0 (primary SIM) or 1 (secondary SIM)");
         }
-        logger.log(`[CALL_PHONE_TOOL] 📞 Preparing to call phone number: ${params.phoneNumber}`);
-        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId} (${slotId === 0 ? "主卡" : "副卡"})`);
         // Get session context
-        logger.log(`[CALL_PHONE_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[CALL_PHONE_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Call phone tool can only be used during an active conversation.");
         }
-        logger.log(`[CALL_PHONE_TOOL] ✅ Session context found`);
-        logger.log(`[CALL_PHONE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[CALL_PHONE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[CALL_PHONE_TOOL] ✅ WebSocket manager obtained`);
         // Build StartCall command
-        logger.log(`[CALL_PHONE_TOOL] 📦 Building StartCall command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -97,34 +78,22 @@ export const callPhoneTool = {
                 pageControlRelated: false,
             },
         };
-        logger.log(`[CALL_PHONE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
         // Send command and wait for response (60 second timeout)
-        logger.log(`[CALL_PHONE_TOOL] ⏳ Setting up promise to wait for call response...`);
-        logger.log(`[CALL_PHONE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[CALL_PHONE_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(`[CALL_PHONE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "StartCall") {
-                    logger.log(`[CALL_PHONE_TOOL] 🎯 StartCall event received`);
-                    logger.log(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[CALL_PHONE_TOOL] ✅ Call response received`);
-                        logger.log(`[CALL_PHONE_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(`[CALL_PHONE_TOOL] ❌ Device returned error`);
-                            logger.error(`[CALL_PHONE_TOOL]   - code: ${code}`);
                             const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[CALL_PHONE_TOOL]   - errorMsg: ${errorMsg}`);
                             reject(new Error(`拨打电话失败: ${errorMsg} (错误代码: ${code})`));
                             return;
                         }
@@ -136,9 +105,6 @@ export const callPhoneTool = {
                             slotId: slotId,
                             message: "电话拨打成功",
                         };
-                        logger.log(`[CALL_PHONE_TOOL] 🎉 Call initiated successfully`);
-                        logger.log(`[CALL_PHONE_TOOL]   - phoneNumber: ${params.phoneNumber}`);
-                        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId}`);
                         resolve({
                             content: [
                                 {
@@ -149,19 +115,14 @@ export const callPhoneTool = {
                         });
                     }
                     else {
-                        logger.error(`[CALL_PHONE_TOOL] ❌ Call failed`);
-                        logger.error(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
-                        logger.error(`[CALL_PHONE_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
                         const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
                         reject(new Error(`拨打电话失败: ${errorDetail}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[CALL_PHONE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[CALL_PHONE_TOOL] 📤 Sending StartCall command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -170,10 +131,8 @@ export const callPhoneTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[CALL_PHONE_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[CALL_PHONE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/create-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 parameters
 const ALARM_SNOOZE_DURATION_VALUES = [5, 10, 15, 20, 25, 30];
 const ALARM_SNOOZE_TOTAL_VALUES = [0, 1, 3, 5, 10];
@@ -32,7 +31,9 @@ export const createAlarmTool = {
 
 注意事项：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
-b. 使用该工具之前需获取当前真实时间`,
+b. 使用该工具之前需获取当前真实时间
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
     parameters: {
         type: "object",
         properties: {
@@ -69,170 +70,127 @@ b. 使用该工具之前需获取当前真实时间`,
         required: ["alarmTime"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[CREATE_ALARM_TOOL] 🚀 Starting execution`);
-        logger.log(`[CREATE_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[CREATE_ALARM_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[CREATE_ALARM_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // ===== Validate required parameter: alarmTime =====
         if (!params.alarmTime || typeof params.alarmTime !== "string") {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Missing or invalid alarmTime`);
             throw new Error("Missing required parameter: alarmTime must be a string in format YYYYMMDD hhmmss");
         }
         // Parse and convert alarmTime to timestamp
-        logger.log(`[CREATE_ALARM_TOOL] 🕒 Parsing alarmTime: ${params.alarmTime}`);
         const alarmTimeMs = parseAlarmTimeToTimestamp(params.alarmTime);
         if (alarmTimeMs === null) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmTime format`);
             throw new Error("Invalid alarmTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 143000)");
         }
-        logger.log(`[CREATE_ALARM_TOOL] ✅ alarmTime converted to timestamp: ${alarmTimeMs}`);
         // ===== Validate and set optional parameters with defaults =====
         // alarmTitle - default to "闹钟"
         const alarmTitle = params.alarmTitle && typeof params.alarmTitle === "string"
             ? params.alarmTitle
             : "闹钟";
-        logger.log(`[CREATE_ALARM_TOOL]   - alarmTitle: ${alarmTitle}`);
         // alarmSnoozeDuration - default 10
         let alarmSnoozeDuration = 10;
         if (params.alarmSnoozeDuration !== undefined && params.alarmSnoozeDuration !== null) {
             if (typeof params.alarmSnoozeDuration !== "number") {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmSnoozeDuration type`);
                 throw new Error("alarmSnoozeDuration must be a number");
             }
             if (!ALARM_SNOOZE_DURATION_VALUES.includes(params.alarmSnoozeDuration)) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmSnoozeDuration value: ${params.alarmSnoozeDuration}`);
                 throw new Error(`alarmSnoozeDuration must be one of: ${ALARM_SNOOZE_DURATION_VALUES.join(", ")}`);
             }
             alarmSnoozeDuration = params.alarmSnoozeDuration;
         }
-        logger.log(`[CREATE_ALARM_TOOL]   - alarmSnoozeDuration: ${alarmSnoozeDuration}`);
         // alarmSnoozeTotal - default 0
         let alarmSnoozeTotal = 0;
         if (params.alarmSnoozeTotal !== undefined && params.alarmSnoozeTotal !== null) {
             if (typeof params.alarmSnoozeTotal !== "number") {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmSnoozeTotal type`);
                 throw new Error("alarmSnoozeTotal must be a number");
             }
             if (!ALARM_SNOOZE_TOTAL_VALUES.includes(params.alarmSnoozeTotal)) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmSnoozeTotal value: ${params.alarmSnoozeTotal}`);
                 throw new Error(`alarmSnoozeTotal must be one of: ${ALARM_SNOOZE_TOTAL_VALUES.join(", ")}`);
             }
             alarmSnoozeTotal = params.alarmSnoozeTotal;
         }
-        logger.log(`[CREATE_ALARM_TOOL]   - alarmSnoozeTotal: ${alarmSnoozeTotal}`);
         // alarmRingDuration - default 20
         let alarmRingDuration = 20;
         if (params.alarmRingDuration !== undefined && params.alarmRingDuration !== null) {
             if (typeof params.alarmRingDuration !== "number") {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmRingDuration type`);
                 throw new Error("alarmRingDuration must be a number");
             }
             if (!ALARM_RING_DURATION_VALUES.includes(params.alarmRingDuration)) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid alarmRingDuration value: ${params.alarmRingDuration}`);
                 throw new Error(`alarmRingDuration must be one of: ${ALARM_RING_DURATION_VALUES.join(", ")}`);
             }
             alarmRingDuration = params.alarmRingDuration;
         }
-        logger.log(`[CREATE_ALARM_TOOL]   - alarmRingDuration: ${alarmRingDuration}`);
         // daysOfWakeType - default 0
         let daysOfWakeType = 0;
         if (params.daysOfWakeType !== undefined && params.daysOfWakeType !== null) {
             if (typeof params.daysOfWakeType !== "number") {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid daysOfWakeType type`);
                 throw new Error("daysOfWakeType must be a number");
             }
             if (!DAYS_OF_WAKE_TYPE_VALUES.includes(params.daysOfWakeType)) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid daysOfWakeType value: ${params.daysOfWakeType}`);
                 throw new Error(`daysOfWakeType must be one of: ${DAYS_OF_WAKE_TYPE_VALUES.join(", ")}`);
             }
             daysOfWakeType = params.daysOfWakeType;
         }
-        logger.log(`[CREATE_ALARM_TOOL]   - daysOfWakeType: ${daysOfWakeType}`);
         // daysOfWeek - only required when daysOfWakeType is 3
         let daysOfWeek = [];
         if (daysOfWakeType === 3) {
             if (!params.daysOfWeek) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Missing daysOfWeek when daysOfWakeType=3`);
                 throw new Error("daysOfWeek is required when daysOfWakeType is 3 (custom)");
             }
             // ===== 参数规范化：兼容数组和 JSON 字符串 =====
             let normalizedDaysOfWeek = null;
             // 情况1: 已经是数组
             if (Array.isArray(params.daysOfWeek)) {
-                logger.log(`[CREATE_ALARM_TOOL] ✅ daysOfWeek is already an array`);
                 normalizedDaysOfWeek = params.daysOfWeek;
             }
             // 情况2: 是字符串，尝试解析为 JSON 数组
             else if (typeof params.daysOfWeek === 'string') {
-                logger.log(`[CREATE_ALARM_TOOL] 🔄 daysOfWeek is a string, attempting to parse as JSON...`);
                 try {
                     const parsed = JSON.parse(params.daysOfWeek);
                     if (Array.isArray(parsed)) {
-                        logger.log(`[CREATE_ALARM_TOOL] ✅ Successfully parsed JSON string to array`);
                         normalizedDaysOfWeek = parsed;
                     }
                     else {
-                        logger.error(`[CREATE_ALARM_TOOL] ❌ Parsed JSON is not an array:`, typeof parsed);
                         throw new Error("daysOfWeek must be an array or a JSON string representing an array");
                     }
                 }
                 catch (parseError) {
-                    logger.error(`[CREATE_ALARM_TOOL] ❌ Failed to parse daysOfWeek as JSON:`, parseError);
                     throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
                 }
             }
             // 情况3: 其他类型，报错
             else {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid daysOfWeek type:`, typeof params.daysOfWeek);
                 throw new Error(`daysOfWeek must be an array or a JSON string, got ${typeof params.daysOfWeek}`);
             }
             // 验证数组非空
             if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ daysOfWeek array is empty`);
                 throw new Error("daysOfWeek array cannot be empty");
             }
             // 验证数组长度必须为1
             if (normalizedDaysOfWeek.length !== 1) {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ daysOfWeek array length must be 1, got ${normalizedDaysOfWeek.length}`);
                 throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
             }
             // Validate each day
             for (const day of normalizedDaysOfWeek) {
                 if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
-                    logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid day value: ${day}`);
                     throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
                 }
             }
             daysOfWeek = normalizedDaysOfWeek;
-            logger.log(`[CREATE_ALARM_TOOL]   - daysOfWeek: ${daysOfWeek.join(", ")}`);
         }
         else {
             // daysOfWakeType is not 3, daysOfWeek should not be provided
             if (params.daysOfWeek) {
-                logger.warn(`[CREATE_ALARM_TOOL] ⚠️ daysOfWeek parameter is ignored when daysOfWakeType is not 3 (current: ${daysOfWakeType}). Please remove daysOfWeek parameter.`);
             }
             // Explicitly set to empty array
             daysOfWeek = [];
         }
         // Get session context
-        logger.log(`[CREATE_ALARM_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[CREATE_ALARM_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Create alarm tool can only be used during an active conversation.");
         }
-        logger.log(`[CREATE_ALARM_TOOL] ✅ Session context found`);
-        logger.log(`[CREATE_ALARM_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[CREATE_ALARM_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[CREATE_ALARM_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[CREATE_ALARM_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[CREATE_ALARM_TOOL] ✅ WebSocket manager obtained`);
         // Build CreateAlarm command
-        logger.log(`[CREATE_ALARM_TOOL] 📦 Building CreateAlarm command...`);
         // Build intentParam - only include daysOfWeek when daysOfWakeType is 3
         const intentParam = {
             entityName: "Alarm",
@@ -246,10 +204,8 @@ b. 使用该工具之前需获取当前真实时间`,
         // Only include daysOfWeek when daysOfWakeType is 3
         if (daysOfWakeType === 3 && daysOfWeek.length > 0) {
             intentParam.daysOfWeek = daysOfWeek;
-            logger.log(`[CREATE_ALARM_TOOL]   - Including daysOfWeek in intentParam: ${daysOfWeek.join(", ")}`);
         }
         else {
-            logger.log(`[CREATE_ALARM_TOOL]   - Excluding daysOfWeek from intentParam (daysOfWakeType=${daysOfWakeType})`);
         }
         const command = {
             header: {
@@ -283,25 +239,17 @@ b. 使用该工具之前需获取当前真实时间`,
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[CREATE_ALARM_TOOL] ⏳ Setting up promise to wait for alarm creation response...`);
-        logger.log(`[CREATE_ALARM_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[CREATE_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(`[CREATE_ALARM_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "CreateAlarm") {
-                    logger.log(`[CREATE_ALARM_TOOL] 🎯 CreateAlarm event received`);
-                    logger.log(`[CREATE_ALARM_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     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));
                         // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
@@ -313,18 +261,13 @@ b. 使用该工具之前需获取当前真实时间`,
                         });
                     }
                     else {
-                        logger.error(`[CREATE_ALARM_TOOL] ❌ Alarm creation failed`);
-                        logger.error(`[CREATE_ALARM_TOOL]   - status: ${event.status}`);
-                        logger.error(`[CREATE_ALARM_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
                         reject(new Error(`创建闹钟失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[CREATE_ALARM_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[CREATE_ALARM_TOOL] 📤 Sending CreateAlarm command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -333,10 +276,8 @@ b. 使用该工具之前需获取当前真实时间`,
                 command,
             })
                 .then(() => {
-                logger.log(`[CREATE_ALARM_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[CREATE_ALARM_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);
@@ -356,17 +297,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(`[CREATE_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(`[CREATE_ALARM_TOOL]   - datePart: ${datePart}, timePart: ${timePart}`);
         // Validate lengths
         if (datePart.length !== 8 || timePart.length !== 6) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid part lengths: datePart=${datePart.length}, timePart=${timePart.length}`);
             return null;
         }
         // Parse components
@@ -376,45 +314,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(`[CREATE_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(`[CREATE_ALARM_TOOL] ❌ NaN detected in parsed values`);
             return null;
         }
         // Validate ranges
         if (month < 1 || month > 12) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid month: ${month}`);
             return null;
         }
         if (day < 1 || day > 31) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid day: ${day}`);
             return null;
         }
         if (hour < 0 || hour > 23) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid hour: ${hour}`);
             return null;
         }
         if (minute < 0 || minute > 59) {
-            logger.error(`[CREATE_ALARM_TOOL] ❌ Invalid minute: ${minute}`);
             return null;
         }
         if (second < 0 || second > 59) {
-            logger.error(`[CREATE_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(`[CREATE_ALARM_TOOL] ❌ Generated timestamp is NaN`);
             return null;
         }
         return timestamp;
     }
     catch (error) {
-        logger.error(`[CREATE_ALARM_TOOL] ❌ Exception in parseAlarmTimeToTimestamp:`, error);
         return null;
     }
 }