@ynhcj/xiaoyi-channel 0.0.9 → 0.0.10-beta

package/dist/src/push.d.ts

@@ -5,11 +5,17 @@ import type { XYChannelConfig } from "./types.js";
  */
 export declare class XYPushService {
     private config;
+    private readonly DEFAULT_PUSH_URL;
+    private readonly REQUEST_FROM;
     constructor(config: XYChannelConfig);
+    /**
+     * Generate a random trace ID for request tracking.
+     */
+    private generateTraceId;
     /**
      * Send a push message to a user session.
      */
-    sendPush(content: string, title: string, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */

package/dist/src/push.js

@@ -1,46 +1,135 @@
 // Push message service for scheduled tasks
 import fetch from "node-fetch";
-import { logger } from "./utils/logger.js";
+import { randomUUID } from "crypto";
+import { configManager } from "./utils/config-manager.js";
 /**
  * Service for sending push messages to users.
  * Used for outbound messages and scheduled tasks.
  */
 export class XYPushService {
     config;
+    DEFAULT_PUSH_URL = "https://hag.cloud.huawei.com/open-ability-agent/v1/agent-webhook";
+    REQUEST_FROM = "openclaw";
     constructor(config) {
         this.config = config;
     }
+    /**
+     * Generate a random trace ID for request tracking.
+     */
+    generateTraceId() {
+        return `trace-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
     /**
      * Send a push message to a user session.
      */
-    async sendPush(content, title, sessionId) {
-        const pushUrl = this.config.pushUrl || `${this.config.fileUploadUrl}/push`;
-        logger.debug(`Sending push message: title="${title}"`);
+    async sendPush(content, title, data, sessionId) {
+        const pushUrl = this.config.pushUrl || this.DEFAULT_PUSH_URL;
+        const traceId = this.generateTraceId();
+        // Get dynamic pushId for the session (falls back to config pushId)
+        const dynamicPushId = configManager.getPushId(sessionId);
+        const pushId = dynamicPushId || this.config.pushId;
+        console.log(`[PUSH] 📤 Preparing to send push message`);
+        console.log(`[PUSH]   - Title: "${title}"`);
+        console.log(`[PUSH]   - Content length: ${content.length} chars`);
+        console.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
+        console.log(`[PUSH]   - Trace ID: ${traceId}`);
+        console.log(`[PUSH]   - Push URL: ${pushUrl}`);
+        if (dynamicPushId) {
+            console.log(`[PUSH]   - Using dynamic pushId (from session): ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Full dynamic pushId: ${pushId}`);
+        }
+        else {
+            console.log(`[PUSH]   - Using config pushId (fallback): ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Full config pushId: ${pushId}`);
+        }
+        console.log(`[PUSH]   - API ID: ${this.config.apiId}`);
+        console.log(`[PUSH]   - UID: ${this.config.uid}`);
         try {
-            const request = {
-                apiKey: this.config.apiKey,
-                apiId: this.config.apiId,
-                pushId: this.config.pushId,
-                sessionId: sessionId || "default",
-                title,
-                content,
+            const requestBody = {
+                jsonrpc: "2.0",
+                id: randomUUID(),
+                result: {
+                    id: randomUUID(),
+                    apiId: this.config.apiId,
+                    pushId: pushId, // Use dynamic pushId
+                    pushText: title,
+                    kind: "task",
+                    artifacts: [
+                        {
+                            artifactId: randomUUID(),
+                            parts: [
+                                {
+                                    kind: "text",
+                                    text: content,
+                                },
+                            ],
+                        },
+                    ],
+                },
             };
+            console.log(`[PUSH] Full request body:`, JSON.stringify(requestBody, null, 2));
             const response = await fetch(pushUrl, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "x-hag-trace-id": traceId,
+                    "x-uid": this.config.uid,
                     "x-api-key": this.config.apiKey,
-                    "x-request-from": "openclaw",
+                    "x-request-from": this.REQUEST_FROM,
                 },
-                body: JSON.stringify(request),
+                body: JSON.stringify(requestBody),
             });
+            // Log response status and headers
+            console.log(`[PUSH] 📥 Response received`);
+            console.log(`[PUSH]   - HTTP Status: ${response.status} ${response.statusText}`);
+            console.log(`[PUSH]   - Content-Type: ${response.headers.get('content-type')}`);
+            console.log(`[PUSH]   - Content-Length: ${response.headers.get('content-length')}`);
             if (!response.ok) {
-                throw new Error(`Push failed: HTTP ${response.status}`);
+                const errorText = await response.text();
+                console.log(`[PUSH] ❌ Push request failed`);
+                console.log(`[PUSH]   - HTTP Status: ${response.status}`);
+                console.log(`[PUSH]   - Response body: ${errorText}`);
+                throw new Error(`Push failed: HTTP ${response.status} - ${errorText}`);
+            }
+            // Try to parse JSON response with detailed error handling
+            let result;
+            try {
+                const responseText = await response.text();
+                console.log(`[PUSH] 📄 Response body length: ${responseText.length} chars`);
+                console.log(`[PUSH] 📄 Response body preview: ${responseText.substring(0, 200)}`);
+                if (!responseText || responseText.trim() === '') {
+                    console.log(`[PUSH] ⚠️ Received empty response body`);
+                    result = {};
+                }
+                else {
+                    result = JSON.parse(responseText);
+                }
+            }
+            catch (parseError) {
+                console.log(`[PUSH] ❌ Failed to parse JSON response`);
+                console.log(`[PUSH]   - Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                throw new Error(`Invalid JSON response from push service: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
             }
-            logger.log(`Push message sent successfully: "${title}"`);
+            console.log(`[PUSH] ✅ Push message sent successfully`);
+            console.log(`[PUSH]   - Title: "${title}"`);
+            console.log(`[PUSH]   - Trace ID: ${traceId}`);
+            console.log(`[PUSH]   - Used pushId: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Response:`, result);
         }
         catch (error) {
-            logger.error("Failed to send push message:", error);
+            console.log(`[PUSH] ❌ Failed to send push message`);
+            console.log(`[PUSH]   - Trace ID: ${traceId}`);
+            console.log(`[PUSH]   - Target URL: ${pushUrl}`);
+            console.log(`[PUSH]   - Push ID: ${pushId.substring(0, 20)}...`);
+            if (error instanceof Error) {
+                console.log(`[PUSH]   - Error name: ${error.name}`);
+                console.log(`[PUSH]   - Error message: ${error.message}`);
+                console.log(`[PUSH]   - Error stack:`, error.stack);
+            }
+            else {
+                console.log(`[PUSH]   - Error:`, error);
+            }
             throw error;
         }
     }
@@ -48,8 +137,10 @@ export class XYPushService {
      * Send a push message with file attachments.
      */
     async sendPushWithFiles(content, title, fileIds, sessionId) {
-        // Build content with file references
-        const contentWithFiles = `${content}\n\n[文件: ${fileIds.join(", ")}]`;
-        await this.sendPush(contentWithFiles, title, sessionId);
+        const data = {
+            content,
+            fileIds,
+        };
+        await this.sendPush(content, title, data, sessionId);
     }
 }

package/dist/src/reply-dispatcher.js

@@ -1,6 +1,6 @@
 import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 import { getXYRuntime } from "./runtime.js";
-import { sendA2AResponse, sendStatusUpdate } from "./formatter.js";
+import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 /**
  * Create a reply dispatcher for XY channel messages.
@@ -48,7 +48,7 @@ export function createXYReplyDispatcher(params) {
             }).catch((err) => {
                 error(`Failed to send status update:`, err);
             });
-        }, 60000); // 60 seconds
+        }, 30000); // 30 seconds
     };
     /**
      * Stop the status update interval
@@ -87,6 +87,15 @@ export function createXYReplyDispatcher(params) {
                 accumulatedText += text;
                 hasSentResponse = true;
                 log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
+                // Also stream text as reasoningText for real-time display
+                await sendReasoningTextUpdate({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
             }
             catch (deliverError) {
                 error(`Failed to deliver message:`, deliverError);
@@ -119,6 +128,16 @@ export function createXYReplyDispatcher(params) {
             if (hasSentResponse && !finalSent) {
                 log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
+                    // Send status update before final message
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
                     await sendA2AResponse({
                         config,
                         sessionId,
@@ -137,14 +156,38 @@ export function createXYReplyDispatcher(params) {
             }
             else {
                 log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                // Task was interrupted - send failure status and error response
+                try {
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await sendA2AResponse({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                }
             }
             // Stop status updates
             stopStatusInterval();
         },
         onCleanup: () => {
             log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Stop status updates
-            stopStatusInterval();
         },
     });
     return {
@@ -152,6 +195,106 @@ export function createXYReplyDispatcher(params) {
         replyOptions: {
             ...replyOptions,
             onModelSelected: prefixContext.onModelSelected,
+            // 🔧 Tool execution start callback
+            onToolStart: async ({ name, phase }) => {
+                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: `正在使用工具: ${toolName}...`,
+                            state: "working",
+                        });
+                        log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                    }
+                    catch (err) {
+                        error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                    }
+                }
+            },
+            // 🔧 Tool execution result callback
+            onToolResult: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
+                log(`[TOOL RESULT]   - text.length=${text.length}`);
+                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
+                log(`[TOOL RESULT]   - isError=${payload.isError}`);
+                if (text.length > 0) {
+                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: resultText,
+                            state: "working",
+                        });
+                        log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                    }
+                }
+                catch (err) {
+                    error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                }
+            },
+            // 🧠 Reasoning/thinking process streaming callback
+            onReasoningStream: async (payload) => {
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[REASONING STREAM]   - text.length=${text.length}`);
+                if (text.length > 0) {
+                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                // try {
+                //   if (text.length > 0) {
+                //     await sendReasoningTextUpdate({
+                //       config,
+                //       sessionId,
+                //       taskId,
+                //       messageId,
+                //       text,
+                //     });
+                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
+                //   }
+                // } catch (err) {
+                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
+                // }
+            },
+            // 📝 Partial reply streaming callback (real-time preview)
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
+                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
+                if (text.length > 0) {
+                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0) {
+                        await sendReasoningTextUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                }
+            },
         },
         markDispatchIdle,
         startStatusInterval, // Expose this to be called immediately

package/dist/src/tools/calendar-tool.d.ts

@@ -0,0 +1,6 @@
+/**
+ * XY calendar event tool - creates a calendar event on user's device.
+ * Requires title, dtStart (start time), and dtEnd (end time) parameters.
+ * Time format must be: yyyy-mm-dd hh:mm:ss
+ */
+export declare const calendarTool: any;

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

@@ -0,0 +1,167 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } 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.
+ * Time format must be: yyyy-mm-dd hh:mm:ss
+ */
+export const calendarTool = {
+    name: "create_calendar_event",
+    label: "Create Calendar Event",
+    description: "在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "日程标题/名称",
+            },
+            dtStart: {
+                type: "string",
+                description: "日程开始时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）",
+            },
+            dtEnd: {
+                type: "string",
+                description: "日程结束时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 17:30:00）",
+            },
+        },
+        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 = getLatestSessionContext();
+        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",
+                name: "ActionAndResult",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "CreateCalendarEvent",
+                    bundleName: "com.huawei.hmos.calendardata",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        title: params.title,
+                        dtStart: dtStartMs,
+                        dtEnd: dtEndMs,
+                    },
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // 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: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    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,
+                taskId,
+                messageId,
+                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/location-tool.js

@@ -9,7 +9,7 @@ import { logger } from "../utils/logger.js";
 export const locationTool = {
     name: "get_user_location",
     label: "Get User Location",
-    description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。",
+    description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
     parameters: {
         type: "object",
         properties: {},
@@ -47,27 +47,37 @@ export const locationTool = {
                 name: "Action",
             },
             payload: {
+                cardParam: {},
                 executeParam: {
                     achieveType: "INTENT",
                     actionResponse: true,
                     bundleName: "com.huawei.hmos.aidispatchservice",
+                    dimension: "",
+                    executeMode: "background",
                     intentName: "GetCurrentLocation",
                     intentParam: {},
                     needUnlock: true,
+                    permissionId: [],
                     timeOut: 5,
                 },
                 needUploadResult: true,
+                pageControlRelated: false,
+                responses: [{
+                        displayText: "",
+                        resultCode: "",
+                        ttsText: "",
+                    }],
             },
         };
-        // Send command and wait for response (5 second timeout)
+        // Send command and wait for response (60 second timeout)
         logger.log(`[LOCATION_TOOL] ⏳ Setting up promise to wait for location response...`);
-        logger.log(`[LOCATION_TOOL]   - Timeout: 5 seconds`);
+        logger.log(`[LOCATION_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[LOCATION_TOOL] ⏰ Timeout: No response received within 5 seconds`);
+                logger.error(`[LOCATION_TOOL] ⏰ Timeout: No response received within 60 seconds`);
                 wsManager.off("data-event", handler);
-                reject(new Error("获取位置超时（5秒）"));
-            }, 5000);
+                reject(new Error("获取位置超时（60秒）"));
+            }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
                 logger.log(`[LOCATION_TOOL] 📨 Received data event:`, JSON.stringify(event));

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

@@ -9,7 +9,7 @@ import { logger } from "../utils/logger.js";
 export const noteTool = {
     name: "create_note",
     label: "Create Note",
-    description: "在用户设备上创建备忘录。需要提供备忘录标题和内容。",
+    description: "在用户设备上创建备忘录。需要提供备忘录标题和内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
     parameters: {
         type: "object",
         properties: {
@@ -72,12 +72,12 @@ export const noteTool = {
                 pageControlRelated: false,
             },
         };
-        // Send command and wait for response (5 second timeout)
+        // Send command and wait for response (60 second timeout)
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 wsManager.off("data-event", handler);
-                reject(new Error("创建备忘录超时（5秒）"));
-            }, 5000);
+                reject(new Error("创建备忘录超时（60秒）"));
+            }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
                 logger.debug("Received data event:", event);

package/dist/src/tools/search-calendar-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * XY search calendar event tool - searches calendar events on user's device.
+ * Returns matching events based on time range and optional title filter.
+ *
+ * Time range guidelines:
+ * - For a specific day: use 00:00:00 to 23:59:59 of that day
+ * - For morning: 06:00:00 to 12:00:00
+ * - For afternoon: 12:00:00 to 18:00:00
+ * - For evening: 18:00:00 to 24:00:00
+ * - For a specific time: use ±1 hour range (e.g., for 3PM, use 14:00:00 to 16:00:00)
+ */
+export declare const searchCalendarTool: any;