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

package/dist/src/tools/send-file-to-user-tool.js

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 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";
@@ -65,7 +64,6 @@ function normalizeToArray(param) {
  * Download remote file to local temp directory
  */
 async function downloadRemoteFile(url) {
-    logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading remote file: ${url}`);
     try {
         const response = await fetch(url);
         if (!response.ok) {
@@ -88,11 +86,9 @@ async function downloadRemoteFile(url) {
         const arrayBuffer = await response.arrayBuffer();
         const buffer = Buffer.from(arrayBuffer);
         await fs.writeFile(localPath, buffer);
-        logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ File downloaded to: ${localPath}`);
         return localPath;
     }
     catch (error) {
-        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to download file from ${url}:`, error);
         throw new Error(`Failed to download remote file: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
@@ -136,54 +132,34 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
         });
         // Create the main execution promise
         const executionPromise = (async () => {
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 🚀 Starting execution`);
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - toolCallId: ${toolCallId}`);
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - params (raw):`, JSON.stringify(params));
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - timestamp: ${new Date().toISOString()}`);
             // Validate that at least one parameter is provided
             if (!params.fileLocalUrls && !params.fileRemoteUrls) {
-                logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Missing both fileLocalUrls and fileRemoteUrls parameters`);
                 throw new Error("At least one of fileLocalUrls or fileRemoteUrls must be provided");
             }
             // Normalize fileLocalUrls parameter
             let fileLocalUrls = [];
             if (params.fileLocalUrls) {
-                logger.log(`[SEND_FILE_TO_USER_TOOL] 🔄 Normalizing fileLocalUrls parameter...`);
                 fileLocalUrls = normalizeToArray(params.fileLocalUrls);
                 if (fileLocalUrls.length === 0) {
-                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ fileLocalUrls array is empty`);
                     throw new Error("fileLocalUrls array cannot be empty");
                 }
-                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Normalized fileLocalUrls:`, JSON.stringify(fileLocalUrls));
             }
             // Normalize fileRemoteUrls parameter
             let fileRemoteUrls = [];
             if (params.fileRemoteUrls) {
-                logger.log(`[SEND_FILE_TO_USER_TOOL] 🔄 Normalizing fileRemoteUrls parameter...`);
                 fileRemoteUrls = normalizeToArray(params.fileRemoteUrls);
                 if (fileRemoteUrls.length === 0) {
-                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ fileRemoteUrls array is empty`);
                     throw new Error("fileRemoteUrls array cannot be empty");
                 }
-                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Normalized fileRemoteUrls:`, JSON.stringify(fileRemoteUrls));
             }
             // Get session context
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 🔍 Attempting to get session context...`);
             const sessionContext = getCurrentSessionContext();
             if (!sessionContext) {
-                logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ FAILED: No active session found!`);
-                logger.error(`[SEND_FILE_TO_USER_TOOL]   - toolCallId: ${toolCallId}`);
                 throw new Error("No active XY session found. Send file to user tool can only be used during an active conversation.");
             }
-            logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Session context found`);
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - taskId: ${sessionContext.taskId}`);
-            logger.log(`[SEND_FILE_TO_USER_TOOL]   - messageId: ${sessionContext.messageId}`);
             const { config, sessionId, taskId, messageId } = sessionContext;
             // Get WebSocket manager
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 🔌 Getting WebSocket manager...`);
             const wsManager = getXYWebSocketManager(config);
-            logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ WebSocket manager obtained`);
             // Create upload service
             const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
             // Collect all local file paths to upload
@@ -191,61 +167,48 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
             const downloadedFiles = [];
             // Download remote files to local temp directory
             if (fileRemoteUrls.length > 0) {
-                logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading ${fileRemoteUrls.length} remote files...`);
                 for (let i = 0; i < fileRemoteUrls.length; i++) {
                     const remoteUrl = fileRemoteUrls[i];
-                    logger.log(`[SEND_FILE_TO_USER_TOOL] 📥 Downloading remote file ${i + 1}/${fileRemoteUrls.length}: ${remoteUrl}`);
                     try {
                         const localPath = await downloadRemoteFile(remoteUrl);
                         allLocalPaths.push(localPath);
                         downloadedFiles.push(localPath);
                     }
                     catch (error) {
-                        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to download file ${i + 1}:`, error);
                         throw new Error(`Failed to download remote file ${remoteUrl}: ${error instanceof Error ? error.message : String(error)}`);
                     }
                 }
-                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Downloaded ${downloadedFiles.length} remote files`);
             }
             // Upload all local files and get fileIds
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 📤 Uploading ${allLocalPaths.length} files...`);
             const uploadedFiles = [];
             for (let i = 0; i < allLocalPaths.length; i++) {
                 const localPath = allLocalPaths[i];
-                logger.log(`[SEND_FILE_TO_USER_TOOL] 📤 Uploading file ${i + 1}/${allLocalPaths.length}: ${localPath}`);
                 try {
                     // Upload file using three-phase upload
                     const fileId = await uploadService.uploadFile(localPath);
                     if (!fileId) {
-                        logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to upload file: ${localPath} (fileId is empty)`);
                         throw new Error(`Failed to upload file: ${localPath}`);
                     }
                     // Get filename and mime type
                     const fileName = localPath.split("/").pop() || "unknown";
                     const mimeType = getMimeTypeFromFilename(fileName);
                     uploadedFiles.push({ fileName, fileId, mimeType });
-                    logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ File uploaded successfully: ${fileName} -> ${fileId}`);
                 }
                 catch (error) {
-                    logger.error(`[SEND_FILE_TO_USER_TOOL] ❌ Failed to upload file ${i + 1}:`, error);
                     throw new Error(`Failed to upload file ${localPath}: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             // Clean up downloaded files
             if (downloadedFiles.length > 0) {
-                logger.log(`[SEND_FILE_TO_USER_TOOL] 🧹 Cleaning up ${downloadedFiles.length} downloaded files...`);
                 for (const downloadedFile of downloadedFiles) {
                     try {
                         await fs.unlink(downloadedFile);
-                        logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Cleaned up: ${downloadedFile}`);
                     }
                     catch (error) {
-                        logger.warn(`[SEND_FILE_TO_USER_TOOL] ⚠️ Failed to clean up file ${downloadedFile}:`, error);
                     }
                 }
             }
             // Build and send agent_response messages for each file
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 📦 Building and sending agent_response messages...`);
             const sentFiles = [];
             for (const uploadedFile of uploadedFiles) {
                 const { fileName, fileId, mimeType } = uploadedFile;
@@ -281,10 +244,9 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                 };
                 // Send WebSocket message
                 await wsManager.sendMessage(sessionId, agentResponse);
+                console.log(`send ${fileName} file to user success`);
                 sentFiles.push({ fileName, fileId });
-                logger.log(`[SEND_FILE_TO_USER_TOOL] ✅ Sent file to user: ${fileName} (fileId: ${fileId})`);
             }
-            logger.log(`[SEND_FILE_TO_USER_TOOL] 🎉 Successfully sent ${sentFiles.length} files to user`);
             return {
                 content: [
                     {

package/dist/src/tools/send-message-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 send message tool - sends SMS message on user's device.
  * Requires phoneNumber (with +86 prefix) and content parameters.
@@ -9,7 +8,7 @@ import { logger } from "../utils/logger.js";
 export const sendMessageTool = {
     name: "send_message",
     label: "Send Message",
-    description: "通过手机发送短信。需要提供接收方手机号码和短信内容。手机号码会自动添加+86前缀（如果没有的话）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "通过手机发送短信。需要提供接收方手机号码和短信内容。手机号码会自动添加+86前缀（如果没有的话）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -25,18 +24,12 @@ export const sendMessageTool = {
         required: ["phoneNumber", "content"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[SEND_MESSAGE_TOOL] 🚀 Starting execution`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[SEND_MESSAGE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate phoneNumber parameter
         if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
-            logger.error(`[SEND_MESSAGE_TOOL] ❌ Missing or invalid phoneNumber parameter`);
             throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
         }
         // Validate content parameter
         if (!params.content || typeof params.content !== "string" || params.content.trim() === "") {
-            logger.error(`[SEND_MESSAGE_TOOL] ❌ Missing or invalid content parameter`);
             throw new Error("Missing required parameter: content must be a non-empty string");
         }
         // Normalize phone number: add +86 prefix if not present
@@ -51,30 +44,16 @@ export const sendMessageTool = {
                 phoneNumber = phoneNumber.substring(2);
             }
             phoneNumber = `+86${phoneNumber}`;
-            logger.log(`[SEND_MESSAGE_TOOL] 📞 Normalized phone number: ${params.phoneNumber} -> ${phoneNumber}`);
         }
-        logger.log(`[SEND_MESSAGE_TOOL] 📤 Preparing to send message`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - phoneNumber: ${phoneNumber}`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - content length: ${params.content.length} characters`);
         // Get session context
-        logger.log(`[SEND_MESSAGE_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[SEND_MESSAGE_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[SEND_MESSAGE_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Send message tool can only be used during an active conversation.");
         }
-        logger.log(`[SEND_MESSAGE_TOOL] ✅ Session context found`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[SEND_MESSAGE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[SEND_MESSAGE_TOOL] ✅ WebSocket manager obtained`);
         // Build SendShortMessage command
-        logger.log(`[SEND_MESSAGE_TOOL] 📦 Building SendShortMessage command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -109,65 +88,37 @@ export const sendMessageTool = {
                 pageControlRelated: false,
             },
         };
-        logger.log(`[SEND_MESSAGE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
         // Send command and wait for response (60 second timeout)
-        logger.log(`[SEND_MESSAGE_TOOL] ⏳ Setting up promise to wait for send message response...`);
-        logger.log(`[SEND_MESSAGE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[SEND_MESSAGE_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(`[SEND_MESSAGE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "SendShortMessage") {
-                    logger.log(`[SEND_MESSAGE_TOOL] 🎯 SendShortMessage event received`);
-                    logger.log(`[SEND_MESSAGE_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[SEND_MESSAGE_TOOL] ✅ Send message response received`);
-                        logger.log(`[SEND_MESSAGE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
-                        // Check for error code in outputs
-                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
-                        if (code !== null && code !== 0) {
-                            logger.error(`[SEND_MESSAGE_TOOL] ❌ Device returned error`);
-                            logger.error(`[SEND_MESSAGE_TOOL]   - code: ${code}`);
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[SEND_MESSAGE_TOOL]   - errorMsg: ${errorMsg}`);
-                            reject(new Error(`发送短信失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
-                        // Extract result with safe checks
-                        const result = event.outputs.result || {};
-                        logger.log(`[SEND_MESSAGE_TOOL] 🎉 Message sent successfully`);
-                        logger.log(`[SEND_MESSAGE_TOOL]   - phoneNumber: ${phoneNumber}`);
-                        logger.log(`[SEND_MESSAGE_TOOL]   - result:`, JSON.stringify(result));
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
-                                },
-                            ],
+                                    text: JSON.stringify(event.outputs),
+                                }
+                            ]
                         });
                     }
                     else {
-                        logger.error(`[SEND_MESSAGE_TOOL] ❌ Send message failed`);
-                        logger.error(`[SEND_MESSAGE_TOOL]   - status: ${event.status}`);
-                        logger.error(`[SEND_MESSAGE_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(`[SEND_MESSAGE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[SEND_MESSAGE_TOOL] 📤 Sending SendShortMessage command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -176,10 +127,8 @@ export const sendMessageTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[SEND_MESSAGE_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[SEND_MESSAGE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/session-manager.d.ts

@@ -5,6 +5,7 @@ export interface SessionContext {
     taskId: string;
     messageId: string;
     agentId: string;
+    deviceType?: string;
 }
 /**
  * Register a session context for tool access.

package/dist/src/tools/session-manager.js

@@ -1,7 +1,6 @@
 // Session manager for XY tool context
 // Stores active session contexts that tools can access
 import { AsyncLocalStorage } from "async_hooks";
-import { logger } from "../utils/logger.js";
 import { configManager } from "../utils/config-manager.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 // Map of sessionKey -> SessionContextWithRef
@@ -13,19 +12,12 @@ const asyncLocalStorage = new AsyncLocalStorage();
  * Should be called when starting to process a message.
  */
 export function registerSession(sessionKey, context) {
-    logger.log(`[SESSION_MANAGER] 📝 Registering session: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
-    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
-    logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
-    logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
     const existing = activeSessions.get(sessionKey);
     if (existing) {
         // 更新上下文，增加引用计数
         existing.taskId = context.taskId;
         existing.messageId = context.messageId;
         existing.refCount++;
-        logger.log(`[SESSION_MANAGER]   - Updated existing, refCount=${existing.refCount}`);
     }
     else {
         // 新建
@@ -33,45 +25,30 @@ export function registerSession(sessionKey, context) {
             ...context,
             refCount: 1,
         });
-        logger.log(`[SESSION_MANAGER]   - Created new, refCount=1`);
     }
-    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Unregister a session context.
  * Should be called when message processing is complete.
  */
 export function unregisterSession(sessionKey) {
-    logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
     const existing = activeSessions.get(sessionKey);
     if (!existing) {
-        logger.log(`[SESSION_MANAGER]   - Session not found`);
         return;
     }
     existing.refCount--;
-    logger.log(`[SESSION_MANAGER]   - Decremented refCount: ${existing.refCount}`);
     if (existing.refCount <= 0) {
         activeSessions.delete(sessionKey);
         configManager.clearSession(existing.sessionId);
-        logger.log(`[SESSION_MANAGER]   - Deleted (refCount=0)`);
     }
-    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Get session context by sessionKey.
  * Returns null if session not found.
  */
 export function getSessionContext(sessionKey) {
-    logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
     const contextWithRef = activeSessions.get(sessionKey) ?? null;
-    logger.log(`[SESSION_MANAGER]   - Found: ${contextWithRef !== null}`);
     if (contextWithRef) {
-        logger.log(`[SESSION_MANAGER]   - sessionId: ${contextWithRef.sessionId}`);
         // 返回时去掉refCount字段
         const { refCount, ...context } = contextWithRef;
         return context;
@@ -85,20 +62,12 @@ export function getSessionContext(sessionKey) {
  * Returns null if no sessions are active.
  */
 export function getLatestSessionContext() {
-    logger.log(`[SESSION_MANAGER] 🔍 Getting latest session context`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions count: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Active session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
     if (activeSessions.size === 0) {
-        logger.error(`[SESSION_MANAGER]   - ❌ No active sessions found!`);
         return null;
     }
     // Return the last added session
     const sessions = Array.from(activeSessions.values());
     const latestSessionWithRef = sessions[sessions.length - 1];
-    logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
-    logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSessionWithRef.sessionId}`);
-    logger.log(`[SESSION_MANAGER]     - taskId: ${latestSessionWithRef.taskId}`);
-    logger.log(`[SESSION_MANAGER]     - messageId: ${latestSessionWithRef.messageId}`);
     // 返回时去掉refCount字段
     const { refCount, ...latestSession } = latestSessionWithRef;
     return latestSession;
@@ -108,9 +77,6 @@ export function getLatestSessionContext() {
  * This ensures thread-safe context isolation for concurrent requests.
  */
 export function runWithSessionContext(context, callback) {
-    logger.log(`[SESSION_MANAGER] 🔐 Running with AsyncLocalStorage context`);
-    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
-    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
     return asyncLocalStorage.run(context, callback);
 }
 /**
@@ -125,7 +91,6 @@ export function getCurrentSessionContext() {
     // 1. Get base context from AsyncLocalStorage
     const context = asyncLocalStorage.getStore() ?? null;
     if (!context) {
-        logger.warn(`[SESSION_MANAGER] ⚠️  No session context in AsyncLocalStorage`);
         return null;
     }
     // 2. Get latest taskId and messageId from task-manager
@@ -133,12 +98,6 @@ export function getCurrentSessionContext() {
     const latestMessageId = getCurrentMessageId(context.sessionId);
     // 3. If task-manager has a newer taskId, use the latest value
     if (latestTaskId && latestTaskId !== context.taskId) {
-        logger.log(`[SESSION_MANAGER] 🔄 TaskId updated (interruption detected)`);
-        logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
-        logger.log(`[SESSION_MANAGER]   - Old taskId: ${context.taskId}`);
-        logger.log(`[SESSION_MANAGER]   - New taskId: ${latestTaskId}`);
-        logger.log(`[SESSION_MANAGER]   - Old messageId: ${context.messageId}`);
-        logger.log(`[SESSION_MANAGER]   - New messageId: ${latestMessageId ?? context.messageId}`);
         // Return updated context (create new object, don't modify original)
         return {
             ...context,
@@ -147,9 +106,5 @@ export function getCurrentSessionContext() {
         };
     }
     // 4. No update needed, return original context
-    logger.log(`[SESSION_MANAGER] ✅ Got current session context from AsyncLocalStorage`);
-    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
-    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
-    logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
     return context;
 }

package/dist/src/tools/timestamp-to-utc8-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * XY timestamp to UTC+8 time tool - converts timestamp to UTC+8 time format.
+ * Supports both second-level and millisecond-level timestamps.
+ *
+ * This is a utility tool that doesn't require device communication.
+ * It converts Unix timestamp to UTC+8 time in YYYYMMDD hhmmss format.
+ *
+ * Important: The search_calendar_event and search_alarm tools return timestamps.
+ * Call this tool first to convert timestamps to readable UTC+8 time format before
+ * presenting results to users or performing further operations.
+ */
+export declare const timestampToUtc8Tool: any;

package/dist/src/tools/timestamp-to-utc8-tool.js

@@ -0,0 +1,104 @@
+/**
+ * XY timestamp to UTC+8 time tool - converts timestamp to UTC+8 time format.
+ * Supports both second-level and millisecond-level timestamps.
+ *
+ * This is a utility tool that doesn't require device communication.
+ * It converts Unix timestamp to UTC+8 time in YYYYMMDD hhmmss format.
+ *
+ * Important: The search_calendar_event and search_alarm tools return timestamps.
+ * Call this tool first to convert timestamps to readable UTC+8 time format before
+ * presenting results to users or performing further operations.
+ */
+export const timestampToUtc8Tool = {
+    name: "convert_timestamp_to_utc8_time",
+    label: "Convert Timestamp to UTC+8 Time",
+    description: `将时间戳转换为标准 UTC+8 时间格式。支持秒级时间戳和毫秒级时间戳。
+
+输入参数：
+- timestamp: 时间戳（数字类型），可以是秒级（10位）或毫秒级（13位）
+
+输出格式：
+- YYYYMMDD hhmmss（例如：20240315 143000 表示 2024年3月15日 14:30:00 北京时间）
+
+重要说明：
+搜索日程工具（search_calendar_event）和搜索闹钟工具（search_alarm）等工具中返回结果如果包含时间戳。
+建议优先调用本时间戳转换工具，将时间戳转换为标准北京时间格式，再基于标准时间进行用户回答或下一步操作。
+
+示例：
+- 输入：1710498600（秒级）或 1710498600000（毫秒级）
+- 输出：20240315 143000`,
+    parameters: {
+        type: "object",
+        properties: {
+            timestamp: {
+                type: "number",
+                description: "时间戳，支持秒级（10位）或毫秒级（13位）时间戳",
+            },
+        },
+        required: ["timestamp"],
+    },
+    async execute(toolCallId, params) {
+        // Validate timestamp parameter
+        if (params.timestamp === undefined || params.timestamp === null) {
+            throw new Error("缺少必需参数：timestamp");
+        }
+        const timestamp = params.timestamp;
+        // Validate it's a number
+        if (typeof timestamp !== "number") {
+            throw new Error("timestamp 必须是数字类型");
+        }
+        // Check if timestamp is valid
+        if (isNaN(timestamp)) {
+            throw new Error("timestamp 不是有效数字");
+        }
+        // Determine if it's seconds or milliseconds
+        // Millisecond timestamps are typically 13 digits (year 2024+)
+        // Second timestamps are typically 10 digits
+        let timestampInMs;
+        const timestampStr = Math.abs(timestamp).toString();
+        if (timestampStr.length === 13) {
+            // It's already in milliseconds
+            timestampInMs = timestamp;
+        }
+        else if (timestampStr.length === 10) {
+            // It's in seconds, convert to milliseconds
+            timestampInMs = timestamp * 1000;
+        }
+        else if (timestamp > 1000000000000) {
+            // Likely milliseconds (greater than year 2001 in milliseconds)
+            timestampInMs = timestamp;
+        }
+        else {
+            // Likely seconds, convert to milliseconds
+            timestampInMs = timestamp * 1000;
+        }
+        // Create Date object from timestamp
+        const date = new Date(timestampInMs);
+        // Check if date is valid
+        if (isNaN(date.getTime())) {
+            throw new Error("无效的时间戳，无法转换为日期");
+        }
+        // Convert to Beijing time (UTC+8)
+        const beijingTime = new Date(date.getTime() + (8 * 60 * 60 * 1000));
+        // Format: YYYYMMDD hhmmss
+        const year = beijingTime.getUTCFullYear();
+        const month = beijingTime.getUTCMonth() + 1; // Months are 0-indexed
+        const day = beijingTime.getUTCDate();
+        const hours = beijingTime.getUTCHours();
+        const minutes = beijingTime.getUTCMinutes();
+        const seconds = beijingTime.getUTCSeconds();
+        // Pad with leading zeros
+        const formattedDate = `${year}${String(month).padStart(2, '0')}${String(day).padStart(2, '0')}`;
+        const formattedTime = `${String(hours).padStart(2, '0')}${String(minutes).padStart(2, '0')}${String(seconds).padStart(2, '0')}`;
+        const result = `${formattedDate} ${formattedTime}`;
+        // Return the formatted time
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    },
+};