@ynhcj/xiaoyi-channel 1.0.0 → 1.0.2

package/dist/src/bot.js

@@ -1,10 +1,11 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
 import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { configManager } from "./utils/config-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -55,6 +56,18 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // Extract and update push_id if present
+        const pushId = extractPushId(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -99,7 +112,7 @@ export async function handleXYMessage(params) {
         messageBody = `${speaker}: ${messageBody}`;
         // Format agent envelope (following feishu pattern)
         const body = core.channel.reply.formatAgentEnvelope({
-            channel: "XY",
+            channel: "xiaoyi-channel",
             from: speaker,
             timestamp: new Date(),
             envelope: envelopeOptions,

package/dist/src/channel.js

@@ -5,6 +5,7 @@ import { xyOnboardingAdapter } from "./onboarding.js";
 import { locationTool } from "./tools/location-tool.js";
 import { noteTool } from "./tools/note-tool.js";
 import { searchNoteTool } from "./tools/search-note-tool.js";
+import { calendarTool } from "./tools/calendar-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -43,7 +44,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

package/dist/src/outbound.js

@@ -76,8 +76,8 @@ export const xyOutbound = {
         const pushService = new XYPushService(config);
         // Extract title (first 57 chars or first line)
         const title = text.split("\n")[0].slice(0, 57);
-        // Send push message
-        await pushService.sendPush(text, title, actualTo);
+        // Send push message (content, title, data, sessionId)
+        await pushService.sendPush(text, title, undefined, actualTo);
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {

package/dist/src/parser.d.ts

@@ -38,6 +38,11 @@ export declare function isClearContextMessage(method: string): boolean;
  * Check if message is a tasks/cancel request.
  */
 export declare function isTasksCancelMessage(method: string): boolean;
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export declare function extractPushId(parts: A2AMessagePart[]): string | null;
 /**
  * Validate A2A request structure.
  */

package/dist/src/parser.js

@@ -57,6 +57,21 @@ export function isClearContextMessage(method) {
 export function isTasksCancelMessage(method) {
     return method === "tasks/cancel" || method === "tasks_cancel";
 }
+/**
+ * Extract push_id from message parts.
+ * Looks for push_id in data parts under variables.systemVariables.push_id
+ */
+export function extractPushId(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const pushId = part.data.variables?.systemVariables?.push_id;
+            if (pushId && typeof pushId === "string") {
+                return pushId;
+            }
+        }
+    }
+    return null;
+}
 /**
  * Validate A2A request structure.
  */

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,104 @@
 // Push message service for scheduled tasks
 import fetch from "node-fetch";
+import { randomUUID } from "crypto";
 import { logger } from "./utils/logger.js";
+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;
+        logger.log(`[PUSH] 📤 Preparing to send push message`);
+        logger.log(`[PUSH]   - Title: "${title}"`);
+        logger.log(`[PUSH]   - Content length: ${content.length} chars`);
+        logger.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
+        logger.log(`[PUSH]   - Trace ID: ${traceId}`);
+        logger.log(`[PUSH]   - Push URL: ${pushUrl}`);
+        if (dynamicPushId) {
+            logger.log(`[PUSH]   - Using dynamic pushId (from session): ${pushId.substring(0, 20)}...`);
+            logger.log(`[PUSH]   - Full dynamic pushId: ${pushId}`);
+        }
+        else {
+            logger.log(`[PUSH]   - Using config pushId (fallback): ${pushId.substring(0, 20)}...`);
+            logger.log(`[PUSH]   - Full config pushId: ${pushId}`);
+        }
+        logger.log(`[PUSH]   - API ID: ${this.config.apiId}`);
+        logger.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: "data",
+                                    data: data || { content },
+                                },
+                            ],
+                        },
+                    ],
+                },
             };
+            logger.debug(`[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),
             });
             if (!response.ok) {
-                throw new Error(`Push failed: HTTP ${response.status}`);
+                const errorText = await response.text();
+                logger.error(`[PUSH] ❌ Push request failed`);
+                logger.error(`[PUSH]   - HTTP Status: ${response.status}`);
+                logger.error(`[PUSH]   - Error: ${errorText}`);
+                throw new Error(`Push failed: HTTP ${response.status} - ${errorText}`);
             }
-            logger.log(`Push message sent successfully: "${title}"`);
+            const result = await response.json();
+            logger.log(`[PUSH] ✅ Push message sent successfully`);
+            logger.log(`[PUSH]   - Title: "${title}"`);
+            logger.log(`[PUSH]   - Trace ID: ${traceId}`);
+            logger.log(`[PUSH]   - Used pushId: ${pushId.substring(0, 20)}...`);
+            logger.debug(`[PUSH]   - Response:`, result);
         }
         catch (error) {
-            logger.error("Failed to send push message:", error);
+            logger.error(`[PUSH] ❌ Failed to send push message`);
+            logger.error(`[PUSH]   - Trace ID: ${traceId}`);
+            logger.error(`[PUSH]   - Error:`, error);
             throw error;
         }
     }
@@ -48,8 +106,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/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）",
+    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: "Action",
+            },
+            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 (5 second timeout)
+        logger.log(`[CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar event response...`);
+        logger.log(`[CALENDAR_TOOL]   - Timeout: 5 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[CALENDAR_TOOL] ⏰ Timeout: No response received within 5 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("创建日程超时（15秒）"));
+            }, 15000);
+            // 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

@@ -76,8 +76,8 @@ export const locationTool = {
             const timeout = setTimeout(() => {
                 logger.error(`[LOCATION_TOOL] ⏰ Timeout: No response received within 5 seconds`);
                 wsManager.off("data-event", handler);
-                reject(new Error("获取位置超时（5秒）"));
-            }, 5000);
+                reject(new Error("获取位置超时（10秒）"));
+            }, 10000);
             // 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

@@ -76,8 +76,8 @@ export const noteTool = {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 wsManager.off("data-event", handler);
-                reject(new Error("创建备忘录超时（5秒）"));
-            }, 5000);
+                reject(new Error("创建备忘录超时（10秒）"));
+            }, 10000);
             // Listen for data events from WebSocket
             const handler = (event) => {
                 logger.debug("Received data event:", event);

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

@@ -71,8 +71,8 @@ export const searchNoteTool = {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 wsManager.off("data-event", handler);
-                reject(new Error("搜索备忘录超时（5秒）"));
-            }, 5000);
+                reject(new Error("搜索备忘录超时（15秒）"));
+            }, 15000);
             // 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

@@ -155,14 +155,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.js

@@ -317,19 +317,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);
                             }
                         }
                     }
@@ -356,19 +360,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": "1.0.0",
+  "version": "1.0.2",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",