@ynhcj/xiaoyi-channel 0.0.9 → 0.0.10-beta

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

@@ -0,0 +1,220 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search calendar event tool - searches calendar events on user's device.
+ * Returns matching events based on time range and optional title filter.
+ *
+ * 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 const searchCalendarTool = {
+    name: "search_calendar_event",
+    label: "Search Calendar Event",
+    description: `检索用户日历中的日程安排。根据时间范围和可选的日程标题进行检索。时间格式必须为：YYYYMMDD hhmmss（例如：20240115 143000）。
+
+时间范围说明：
+- 查询某一天的日程：使用该天的 00:00:00 到 23:59:59（例如：20240115 000000 到 20240115 235959）
+- 查询上午的日程：使用 06:00:00 到 12:00:00
+- 查询下午的日程：使用 12:00:00 到 18:00:00
+- 查询晚上的日程：使用 18:00:00 到 23:59:59
+- 查询某个时刻附近的日程：使用该时刻前后1小时的区间（例如：查询3点左右的日程，使用 14:00:00 到 16:00:00）
+
+注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "日程起始时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 143000 表示 2024年1月15日 14:30:00）",
+            },
+            endTime: {
+                type: "string",
+                description: "日程结束时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 173000 表示 2024年1月15日 17:30:00）",
+            },
+            title: {
+                type: "string",
+                description: "日程标题/类型（可选），用于过滤特定类型的日程",
+            },
+        },
+        required: ["startTime", "endTime"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.startTime || !params.endTime) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Missing required parameters`);
+            throw new Error("Missing required parameters: startTime and endTime are required");
+        }
+        // Convert time strings to millisecond timestamps
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime input: ${params.startTime}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime input: ${params.endTime}`);
+        // Parse YYYYMMDD hhmmss format
+        const parseTimeString = (timeStr) => {
+            // Remove any extra spaces and split
+            const cleaned = timeStr.trim().replace(/\s+/g, ' ');
+            const parts = cleaned.split(' ');
+            if (parts.length !== 2) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const datePart = parts[0]; // YYYYMMDD
+            const timePart = parts[1]; // hhmmss
+            if (datePart.length !== 8 || timePart.length !== 6) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const year = parseInt(datePart.substring(0, 4), 10);
+            const month = parseInt(datePart.substring(4, 6), 10) - 1; // Month is 0-indexed
+            const day = parseInt(datePart.substring(6, 8), 10);
+            const hours = parseInt(timePart.substring(0, 2), 10);
+            const minutes = parseInt(timePart.substring(2, 4), 10);
+            const seconds = parseInt(timePart.substring(4, 6), 10);
+            const date = new Date(year, month, day, hours, minutes, seconds);
+            return date.getTime();
+        };
+        let startTimeMs;
+        let endTimeMs;
+        try {
+            startTimeMs = parseTimeString(params.startTime);
+            endTimeMs = parseTimeString(params.endTime);
+        }
+        catch (error) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Time parsing error:`, error);
+            throw new Error(`Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000). Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (isNaN(startTimeMs) || isNaN(endTimeMs)) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Invalid time format`);
+            throw new Error("Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000)");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Time conversion successful`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime timestamp: ${startTimeMs}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime timestamp: ${endTimeMs}`);
+        // Get session context
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search calendar tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchCalendarEvent command
+        logger.log(`[SEARCH_CALENDAR_TOOL] 📦 Building SearchCalendarEvent command...`);
+        // Build intentParam with timeInterval and optional title
+        const intentParam = {
+            timeInterval: [startTimeMs, endTimeMs],
+        };
+        if (params.title) {
+            intentParam.title = params.title;
+            logger.log(`[SEARCH_CALENDAR_TOOL]   - Including title filter: ${params.title}`);
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchCalendarEvent",
+                    bundleName: "com.huawei.hmos.calendardata",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar search response...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("检索日程超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchCalendarEvent") {
+                    logger.log(`[SEARCH_CALENDAR_TOOL] 🎯 SearchCalendarEvent event received`);
+                    logger.log(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events retrieved successfully`);
+                        logger.log(`[SEARCH_CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Return the result directly as requested
+                        const result = event.outputs.result;
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Calendar event search failed`);
+                        logger.error(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`检索日程失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📤 Sending SearchCalendarEvent command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

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

@@ -9,7 +9,7 @@ import { logger } from "../utils/logger.js";
 export const searchNoteTool = {
     name: "search_notes",
     label: "Search Notes",
-    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。",
+    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
     parameters: {
         type: "object",
         properties: {
@@ -67,12 +67,12 @@ export const searchNoteTool = {
                 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/session-manager.js

@@ -1,4 +1,5 @@
 import { logger } from "../utils/logger.js";
+import { configManager } from "../utils/config-manager.js";
 // Map of sessionKey -> SessionContext
 const activeSessions = new Map();
 /**
@@ -24,7 +25,13 @@ 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)}`);
+    // Get session context before deleting to clear associated pushId
+    const context = activeSessions.get(sessionKey);
     const existed = activeSessions.delete(sessionKey);
+    // Clear cached pushId for this session
+    if (context) {
+        configManager.clearSession(context.sessionId);
+    }
     logger.log(`[SESSION_MANAGER]   - Deleted: ${existed}`);
     logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
     logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);

package/dist/src/types.d.ts

@@ -75,7 +75,11 @@ export interface A2AArtifact {
     artifactId: string;
     parts: A2AArtifactPart[];
 }
-export type A2AArtifactPart = A2ATextPart | A2ADataPart | A2ACommandPart;
+export interface A2AReasoningTextPart {
+    kind: "reasoningText";
+    reasoningText: string;
+}
+export type A2AArtifactPart = A2ATextPart | A2ADataPart | A2ACommandPart | A2AReasoningTextPart;
 export interface A2ACommandPart {
     kind: "command";
     command: A2ACommand;
@@ -155,14 +159,6 @@ export interface FileUploadCompleteRequest {
 export interface FileUploadCompleteResponse {
     fileId: string;
 }
-export interface PushMessageRequest {
-    apiKey: string;
-    apiId: string;
-    pushId: string;
-    sessionId: string;
-    title: string;
-    content: string;
-}
 export type ServerIdentifier = "server1" | "server2";
 export interface SessionBinding {
     sessionId: string;

package/dist/src/utils/config-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+declare class ConfigManager {
+    private sessionPushIds;
+    private globalPushId;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId: string, pushId: string): void;
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId?: string): string | null;
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Clear all cached push IDs.
+     */
+    clear(): void;
+}
+export declare const configManager: ConfigManager;
+export {};

package/dist/src/utils/config-manager.js

@@ -0,0 +1,56 @@
+// Dynamic configuration manager for runtime updates
+import { logger } from "./logger.js";
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+class ConfigManager {
+    sessionPushIds = new Map();
+    globalPushId = null;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId, pushId) {
+        if (!pushId) {
+            logger.warn(`[ConfigManager] Attempted to set empty pushId for session ${sessionId}`);
+            return;
+        }
+        const previous = this.sessionPushIds.get(sessionId);
+        if (previous !== pushId) {
+            logger.log(`[ConfigManager] ✨ Updated pushId for session ${sessionId}`);
+            logger.log(`[ConfigManager]   - Previous: ${previous ? previous.substring(0, 20) + '...' : 'none'}`);
+            logger.log(`[ConfigManager]   - New:      ${pushId.substring(0, 20)}...`);
+            logger.log(`[ConfigManager]   - Full new pushId: ${pushId}`);
+            this.sessionPushIds.set(sessionId, pushId);
+            this.globalPushId = pushId; // Also update global for backward compatibility
+        }
+    }
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId) {
+        if (sessionId) {
+            const sessionPushId = this.sessionPushIds.get(sessionId);
+            if (sessionPushId) {
+                return sessionPushId;
+            }
+        }
+        return this.globalPushId;
+    }
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId) {
+        this.sessionPushIds.delete(sessionId);
+        logger.debug(`[ConfigManager] Cleared pushId for session ${sessionId}`);
+    }
+    /**
+     * Clear all cached push IDs.
+     */
+    clear() {
+        this.sessionPushIds.clear();
+        this.globalPushId = null;
+        logger.debug(`[ConfigManager] Cleared all cached pushIds`);
+    }
+}
+export const configManager = new ConfigManager();

package/dist/src/websocket.d.ts

@@ -1,6 +1,31 @@
 import { EventEmitter } from "events";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
 import type { XYChannelConfig, OutboundWebSocketMessage } from "./types.js";
+/**
+ * Diagnostics for a single WebSocket connection
+ */
+export interface ConnectionDiagnostic {
+    exists: boolean;
+    readyState: string;
+    stateConnected: boolean;
+    stateReady: boolean;
+    reconnectAttempts: number;
+    lastHeartbeat: number;
+    heartbeatActive: boolean;
+    hasReconnectTimer: boolean;
+    listenerCount: number;
+    isOrphan: boolean;
+}
+/**
+ * Full diagnostics for WebSocket manager
+ */
+export interface ManagerDiagnostics {
+    cacheKey: string;
+    server1: ConnectionDiagnostic;
+    server2: ConnectionDiagnostic;
+    isShuttingDown: boolean;
+    totalEventListeners: number;
+}
 /**
  * Manages dual WebSocket connections to XY servers.
  * Implements session-to-server binding for message routing.
@@ -27,7 +52,12 @@ export declare class XYWebSocketManager extends EventEmitter {
     private isShuttingDown;
     private log;
     private error;
+    private onHealthEvent?;
     constructor(config: XYChannelConfig, runtime?: RuntimeEnv);
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     */
+    setHealthEventCallback(callback: () => void): void;
     /**
      * Check if config matches the current instance.
      */
@@ -49,6 +79,15 @@ export declare class XYWebSocketManager extends EventEmitter {
      * Check if at least one server is ready.
      */
     isReady(): boolean;
+    /**
+     * Get detailed connection diagnostics for monitoring and debugging.
+     * Helps identify orphan connections and connection leaks.
+     */
+    getConnectionDiagnostics(): ManagerDiagnostics;
+    /**
+     * Get diagnostic info for a single server connection.
+     */
+    private getServerDiagnostic;
     /**
      * Connect to a specific server.
      */

package/dist/src/websocket.js

@@ -41,6 +41,8 @@ export class XYWebSocketManager extends EventEmitter {
     // Logging functions following feishu pattern
     log;
     error;
+    // Health event callback
+    onHealthEvent;
     constructor(config, runtime) {
         super();
         this.config = config;
@@ -48,6 +50,12 @@ export class XYWebSocketManager extends EventEmitter {
         this.log = runtime?.log ?? console.log;
         this.error = runtime?.error ?? console.error;
     }
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     */
+    setHealthEventCallback(callback) {
+        this.onHealthEvent = callback;
+    }
     /**
      * Check if config matches the current instance.
      */
@@ -144,19 +152,97 @@ export class XYWebSocketManager extends EventEmitter {
     isReady() {
         return this.state1.ready || this.state2.ready;
     }
+    /**
+     * Get detailed connection diagnostics for monitoring and debugging.
+     * Helps identify orphan connections and connection leaks.
+     */
+    getConnectionDiagnostics() {
+        const cacheKey = `${this.config.apiKey}-${this.config.agentId}`;
+        const server1Diag = this.getServerDiagnostic("server1", this.ws1, this.state1, this.heartbeat1, this.reconnectTimer1);
+        const server2Diag = this.getServerDiagnostic("server2", this.ws2, this.state2, this.heartbeat2, this.reconnectTimer2);
+        // Count total event listeners on the manager
+        const totalEventListeners = this.listenerCount('message') +
+            this.listenerCount('connected') +
+            this.listenerCount('disconnected') +
+            this.listenerCount('error') +
+            this.listenerCount('ready') +
+            this.listenerCount('data-event');
+        return {
+            cacheKey,
+            server1: server1Diag,
+            server2: server2Diag,
+            isShuttingDown: this.isShuttingDown,
+            totalEventListeners,
+        };
+    }
+    /**
+     * Get diagnostic info for a single server connection.
+     */
+    getServerDiagnostic(serverId, ws, state, heartbeat, reconnectTimer) {
+        const exists = ws !== null;
+        let readyState = 'NULL';
+        let listenerCount = 0;
+        if (ws) {
+            switch (ws.readyState) {
+                case WebSocket.CONNECTING:
+                    readyState = 'CONNECTING';
+                    break;
+                case WebSocket.OPEN:
+                    readyState = 'OPEN';
+                    break;
+                case WebSocket.CLOSING:
+                    readyState = 'CLOSING';
+                    break;
+                case WebSocket.CLOSED:
+                    readyState = 'CLOSED';
+                    break;
+            }
+            // Count event listeners on the WebSocket
+            listenerCount = ws.listenerCount('message') +
+                ws.listenerCount('close') +
+                ws.listenerCount('error') +
+                ws.listenerCount('open') +
+                ws.listenerCount('pong');
+        }
+        // Orphan detection: connection is OPEN but has no message listeners
+        const isOrphan = exists &&
+            ws.readyState === WebSocket.OPEN &&
+            ws.listenerCount('message') === 0;
+        return {
+            exists,
+            readyState,
+            stateConnected: state.connected,
+            stateReady: state.ready,
+            reconnectAttempts: state.reconnectAttempts,
+            lastHeartbeat: state.lastHeartbeat,
+            heartbeatActive: heartbeat !== null,
+            hasReconnectTimer: reconnectTimer !== null,
+            listenerCount,
+            isOrphan,
+        };
+    }
     /**
      * Connect to a specific server.
      */
     async connectServer(serverId, url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url, {
+            // Check if URL is wss with IP address to bypass certificate validation
+            const urlObj = new URL(url);
+            const isWssWithIP = urlObj.protocol === 'wss:' && /^(\d{1,3}\.){3}\d{1,3}$/.test(urlObj.hostname);
+            const wsOptions = {
                 headers: {
                     "x-uid": this.config.uid,
                     "x-api-key": this.config.apiKey,
                     "x-agent-id": this.config.agentId,
                     "x-request-from": "openclaw",
                 },
-            });
+            };
+            // Bypass certificate validation for wss with IP address
+            if (isWssWithIP) {
+                this.log(`${serverId}: Bypassing certificate validation for IP address: ${urlObj.hostname}`);
+                wsOptions.rejectUnauthorized = false;
+            }
+            const ws = new WebSocket(url, wsOptions);
             const state = serverId === "server1" ? this.state1 : this.state2;
             // Set the WebSocket instance
             if (serverId === "server1") {
@@ -271,7 +357,8 @@ export class XYWebSocketManager extends EventEmitter {
         }, () => {
             this.error(`Heartbeat timeout for ${serverId}, reconnecting...`);
             this.reconnectServer(serverId);
-        }, serverId, this.log, this.error);
+        }, serverId, this.log, this.error, this.onHealthEvent // ✅ Pass health event callback
+        );
         heartbeat.start();
         if (serverId === "server1") {
             this.heartbeat1 = heartbeat;
@@ -317,19 +404,23 @@ export class XYWebSocketManager extends EventEmitter {
                     // Only emit data-event, don't send to openclaw
                     console.log(`[XY-${serverId}] Message contains only data parts, processing as tool result`);
                     for (const dataPart of dataParts) {
-                        const dataArray = dataPart.data;
-                        if (Array.isArray(dataArray)) {
-                            for (const item of dataArray) {
-                                // Check if it's an UploadExeResult (intent execution result)
-                                if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
-                                    const dataEvent = {
-                                        intentName: item.payload.intentName,
-                                        outputs: item.payload.outputs || {},
-                                        status: "success",
-                                    };
-                                    console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
-                                    this.emit("data-event", dataEvent);
-                                }
+                        // Data format: {events: [{header, payload}, ...]}
+                        const events = dataPart.data?.events;
+                        if (!Array.isArray(events)) {
+                            console.warn(`[XY-${serverId}] dataPart.data.events is not an array, skipping`);
+                            continue;
+                        }
+                        console.log(`[XY-${serverId}] Processing ${events.length} events from data.events`);
+                        for (const item of events) {
+                            // Check if it's an UploadExeResult (intent execution result)
+                            if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
+                                const dataEvent = {
+                                    intentName: item.payload.intentName,
+                                    outputs: item.payload.outputs || {},
+                                    status: "success",
+                                };
+                                console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
+                                this.emit("data-event", dataEvent);
                             }
                         }
                     }
@@ -343,9 +434,12 @@ export class XYWebSocketManager extends EventEmitter {
             // Wrapped format (InboundWebSocketMessage)
             const inboundMsg = parsed;
             console.log(`[XY-${serverId}] Message type: Wrapped, msgType: ${inboundMsg.msgType}`);
-            // Skip heartbeat responses
+            // Handle heartbeat responses
             if (inboundMsg.msgType === "heartbeat") {
-                console.log(`[XY-${serverId}] Skipping ${inboundMsg.msgType} message`);
+                console.log(`[XY-${serverId}] Received heartbeat response`);
+                // ✅ Report health: application-level heartbeat received
+                // This prevents openclaw health-monitor from marking connection as stale
+                this.onHealthEvent?.();
                 return;
             }
             // Handle data messages (e.g., intent execution results)
@@ -356,19 +450,23 @@ export class XYWebSocketManager extends EventEmitter {
                     const dataParts = a2aRequest.params?.message?.parts?.filter((p) => p.kind === "data");
                     if (dataParts && dataParts.length > 0) {
                         for (const dataPart of dataParts) {
-                            const dataArray = dataPart.data;
-                            if (Array.isArray(dataArray)) {
-                                for (const item of dataArray) {
-                                    // Check if it's an UploadExeResult (intent execution result)
-                                    if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
-                                        const dataEvent = {
-                                            intentName: item.payload.intentName,
-                                            outputs: item.payload.outputs || {},
-                                            status: "success",
-                                        };
-                                        console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
-                                        this.emit("data-event", dataEvent);
-                                    }
+                            // Data format: {events: [{header, payload}, ...]}
+                            const events = dataPart.data?.events;
+                            if (!Array.isArray(events)) {
+                                console.warn(`[XY-${serverId}] dataPart.data.events is not an array, skipping`);
+                                continue;
+                            }
+                            console.log(`[XY-${serverId}] Processing ${events.length} events from data.events`);
+                            for (const item of events) {
+                                // Check if it's an UploadExeResult (intent execution result)
+                                if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
+                                    const dataEvent = {
+                                        intentName: item.payload.intentName,
+                                        outputs: item.payload.outputs || {},
+                                        status: "success",
+                                    };
+                                    console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
+                                    this.emit("data-event", dataEvent);
                                 }
                             }
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.9",
+  "version": "0.0.10-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",