@ynhcj/xiaoyi 1.7.0 → 1.8.0

package/dist/auth.d.ts

@@ -22,7 +22,11 @@ export declare class XiaoYiAuth {
      */
     verifyCredentials(credentials: AuthCredentials): boolean;
     /**
-     * Generate authentication message for WebSocket
+     * Generate authentication headers for WebSocket connection
+     */
+    generateAuthHeaders(): Record<string, string>;
+    /**
+     * Generate authentication message for WebSocket (legacy, kept for compatibility)
      */
     generateAuthMessage(): any;
 }

package/dist/auth.js

@@ -76,7 +76,20 @@ class XiaoYiAuth {
         return credentials.signature === expectedSignature;
     }
     /**
-     * Generate authentication message for WebSocket
+     * Generate authentication headers for WebSocket connection
+     */
+    generateAuthHeaders() {
+        const timestamp = Date.now();
+        const signature = this.generateSignature(timestamp);
+        return {
+            "x-access-key": this.ak,
+            "x-sign": signature,
+            "x-ts": timestamp.toString(),
+            "x-agent-id": this.agentId,
+        };
+    }
+    /**
+     * Generate authentication message for WebSocket (legacy, kept for compatibility)
      */
     generateAuthMessage() {
         const credentials = this.generateAuthCredentials();

package/dist/channel.d.ts

@@ -1,15 +1,16 @@
 import type { ChannelOutboundContext, OutboundDeliveryResult, ChannelGatewayStartAccountContext, ChannelGatewayStopAccountContext, ChannelGatewayProbeAccountContext, ChannelMessagingNormalizeTargetContext, ChannelStatusGetAccountStatusContext } from "openclaw";
-import { XiaoYiAccountConfig } from "./types";
+import { XiaoYiChannelConfig } from "./types";
 /**
- * Resolved XiaoYi account configuration
+ * Resolved XiaoYi account configuration (single account mode)
  */
 export interface ResolvedXiaoYiAccount {
     accountId: string;
-    config: XiaoYiAccountConfig;
+    config: XiaoYiChannelConfig;
 }
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
+ * Single account mode only
  */
 export declare const xiaoyiPlugin: {
     id: string;
@@ -30,7 +31,7 @@ export declare const xiaoyiPlugin: {
         nativeCommands: boolean;
     };
     /**
-     * Config adapter - manage accounts
+     * Config adapter - single account mode
      */
     config: {
         listAccountIds: (cfg: any) => string[];
@@ -45,11 +46,11 @@ export declare const xiaoyiPlugin: {
             };
             enabled: boolean;
         };
-        defaultAccountId: (cfg: any) => string | undefined;
+        defaultAccountId: (cfg: any) => "default" | undefined;
         isConfigured: (account: any) => boolean;
         describeAccount: (account: any) => {
             accountId: any;
-            name: any;
+            name: string;
             enabled: any;
             configured: boolean;
         };

package/dist/channel.js

@@ -5,6 +5,7 @@ const runtime_1 = require("./runtime");
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
+ * Single account mode only
  */
 exports.xiaoyiPlugin = {
     id: "xiaoyi",
@@ -14,7 +15,7 @@ exports.xiaoyiPlugin = {
         selectionLabel: "XiaoYi (小艺)",
         docsPath: "/channels/xiaoyi",
         blurb: "小艺 A2A 协议支持，通过 WebSocket 连接。",
-        aliases: ["xy"],
+        aliases: ["xiaoyi"],
     },
     capabilities: {
         chatTypes: ["direct"],
@@ -25,37 +26,24 @@ exports.xiaoyiPlugin = {
         nativeCommands: false,
     },
     /**
-     * Config adapter - manage accounts
+     * Config adapter - single account mode
      */
     config: {
         listAccountIds: (cfg) => {
             const channelConfig = cfg?.channels?.xiaoyi;
-            if (!channelConfig || !channelConfig.accounts) {
+            if (!channelConfig || !channelConfig.enabled) {
                 return [];
             }
-            return Object.keys(channelConfig.accounts);
+            // Single account mode: always return "default"
+            return ["default"];
         },
         resolveAccount: (cfg, accountId) => {
-            const resolvedAccountId = accountId || "default";
+            // Single account mode: always use "default"
+            const resolvedAccountId = "default";
             // Access channel config from cfg.channels.xiaoyi
             const channelConfig = cfg?.channels?.xiaoyi;
             // If channel is not configured yet, return empty config
-            if (!channelConfig || !channelConfig.accounts) {
-                return {
-                    accountId: resolvedAccountId,
-                    config: {
-                        enabled: false,
-                        wsUrl: "",
-                        ak: "",
-                        sk: "",
-                        agentId: "",
-                    },
-                    enabled: false,
-                };
-            }
-            const accountConfig = channelConfig.accounts[resolvedAccountId];
-            // If specific account not found, return empty config
-            if (!accountConfig) {
+            if (!channelConfig) {
                 return {
                     accountId: resolvedAccountId,
                     config: {
@@ -70,17 +58,17 @@ exports.xiaoyiPlugin = {
             }
             return {
                 accountId: resolvedAccountId,
-                config: accountConfig,
-                enabled: accountConfig.enabled !== false,
+                config: channelConfig,
+                enabled: channelConfig.enabled !== false,
             };
         },
         defaultAccountId: (cfg) => {
             const channelConfig = cfg?.channels?.xiaoyi;
-            if (!channelConfig || !channelConfig.accounts) {
+            if (!channelConfig || !channelConfig.enabled) {
                 return undefined;
             }
-            const accountIds = Object.keys(channelConfig.accounts);
-            return accountIds.includes("default") ? "default" : accountIds[0];
+            // Single account mode: always return "default"
+            return "default";
         },
         isConfigured: (account) => {
             // Safely check if all required fields are present and non-empty
@@ -97,7 +85,7 @@ exports.xiaoyiPlugin = {
         },
         describeAccount: (account) => ({
             accountId: account.accountId,
-            name: account.config?.name || 'XiaoYi',
+            name: 'XiaoYi',
             enabled: account.enabled,
             configured: Boolean(account.config?.wsUrl && account.config?.ak && account.config?.sk && account.config?.agentId),
         }),
@@ -110,16 +98,20 @@ exports.xiaoyiPlugin = {
         textChunkLimit: 4000,
         sendText: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
-            const connection = runtime.getConnection(ctx.accountId);
+            const connection = runtime.getConnection();
             if (!connection || !connection.isReady()) {
-                throw new Error(`XiaoYi account ${ctx.accountId} not connected`);
+                throw new Error("XiaoYi channel not connected");
             }
             // Get account config to retrieve agentId
             const resolvedAccount = ctx.account;
             const agentId = resolvedAccount.config.agentId;
+            // Use 'to' as sessionId (it's set from incoming message's sessionId)
+            const sessionId = ctx.to;
+            // Get taskId from runtime's session mapping
+            const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
             // Build A2A response message
             const response = {
-                sessionId: ctx.to, // Use 'to' as sessionId
+                sessionId: sessionId,
                 messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                 timestamp: Date.now(),
                 agentId: agentId,
@@ -137,26 +129,30 @@ exports.xiaoyiPlugin = {
                 } : undefined,
                 status: "success",
             };
-            // Send via WebSocket
-            await connection.sendResponse(response);
+            // Send via WebSocket with taskId and sessionId
+            await connection.sendResponse(response, taskId, sessionId);
             return {
                 channel: "xiaoyi",
                 messageId: response.messageId,
-                conversationId: ctx.to,
+                conversationId: sessionId,
                 timestamp: response.timestamp,
             };
         },
         sendMedia: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
-            const connection = runtime.getConnection(ctx.accountId);
+            const connection = runtime.getConnection();
             if (!connection || !connection.isReady()) {
-                throw new Error(`XiaoYi account ${ctx.accountId} not connected`);
+                throw new Error("XiaoYi channel not connected");
             }
             const resolvedAccount = ctx.account;
             const agentId = resolvedAccount.config.agentId;
+            // Use 'to' as sessionId
+            const sessionId = ctx.to;
+            // Get taskId from runtime's session mapping
+            const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
             // Build A2A response message with media
             const response = {
-                sessionId: ctx.to,
+                sessionId: sessionId,
                 messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                 timestamp: Date.now(),
                 agentId: agentId,
@@ -175,11 +171,11 @@ exports.xiaoyiPlugin = {
                 } : undefined,
                 status: "success",
             };
-            await connection.sendResponse(response);
+            await connection.sendResponse(response, taskId, sessionId);
             return {
                 channel: "xiaoyi",
                 messageId: response.messageId,
-                conversationId: ctx.to,
+                conversationId: sessionId,
                 timestamp: response.timestamp,
             };
         },
@@ -191,12 +187,14 @@ exports.xiaoyiPlugin = {
         startAccount: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
             const resolvedAccount = ctx.account;
-            // Start WebSocket connection
-            await runtime.startAccount(resolvedAccount.accountId, resolvedAccount.config);
+            // Start WebSocket connection (single account mode)
+            await runtime.start(resolvedAccount.config);
             // Setup message handler
-            const connection = runtime.getConnection(resolvedAccount.accountId);
+            const connection = runtime.getConnection();
             if (connection) {
                 connection.on("message", async (message) => {
+                    // Store sessionId -> taskId mapping in runtime
+                    runtime.setTaskIdForSession(message.sessionId, message.id);
                     // Convert A2A message to OpenClaw inbound message format
                     await ctx.handleInboundMessage({
                         channel: "xiaoyi",
@@ -207,24 +205,38 @@ exports.xiaoyiPlugin = {
                         timestamp: message.timestamp,
                         peer: {
                             kind: "dm",
-                            id: message.sender.id,
+                            id: message.sessionId, // Use sessionId as peer id for routing responses
                         },
-                        // Store sessionId for response
                         meta: {
                             sessionId: message.sessionId,
-                            conversationId: message.context?.conversationId,
+                            taskId: message.id,
                         },
                     });
                 });
+                // Setup cancel handler
+                connection.on("cancel", async (data) => {
+                    console.log(`Handling cancel request for task: ${data.taskId}`);
+                    // Emit cancel event to OpenClaw runtime
+                    if (runtime.getRuntime()) {
+                        runtime.getRuntime().emit("task:cancel", {
+                            channel: "xiaoyi",
+                            accountId: resolvedAccount.accountId,
+                            taskId: data.taskId,
+                            sessionId: data.sessionId,
+                        });
+                    }
+                    // Send success response
+                    await connection.sendCancelSuccessResponse(data.sessionId, data.taskId, data.id);
+                });
             }
         },
         stopAccount: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
-            runtime.stopAccount(ctx.accountId);
+            runtime.stop();
         },
         probeAccount: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
-            const isConnected = runtime.isAccountConnected(ctx.accountId);
+            const isConnected = runtime.isConnected();
             return {
                 status: isConnected ? "healthy" : "unhealthy",
                 message: isConnected ? "Connected" : "Disconnected",
@@ -247,7 +259,7 @@ exports.xiaoyiPlugin = {
     status: {
         getAccountStatus: async (ctx) => {
             const runtime = (0, runtime_1.getXiaoYiRuntime)();
-            const connection = runtime.getConnection(ctx.accountId);
+            const connection = runtime.getConnection();
             if (!connection) {
                 return {
                     status: "offline",
@@ -270,7 +282,7 @@ exports.xiaoyiPlugin = {
             else {
                 return {
                     status: "offline",
-                    message: `Reconnect attempts: ${state.reconnectAttempts}`,
+                    message: `Reconnect attempts: ${state.reconnectAttempts}/${state.maxReconnectAttempts}`,
                 };
             }
         },

package/dist/config-schema.d.ts

@@ -23,14 +23,13 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     debug: boolean;
-    accounts?: Record<string, unknown> | undefined;
     name?: string | undefined;
     wsUrl?: string | undefined;
     ak?: string | undefined;
     sk?: string | undefined;
     agentId?: string | undefined;
-}, {
     accounts?: Record<string, unknown> | undefined;
+}, {
     name?: string | undefined;
     enabled?: boolean | undefined;
     wsUrl?: string | undefined;
@@ -38,5 +37,6 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     sk?: string | undefined;
     agentId?: string | undefined;
     debug?: boolean | undefined;
+    accounts?: Record<string, unknown> | undefined;
 }>;
 export type XiaoYiConfig = z.infer<typeof XiaoYiConfigSchema>;

package/dist/index.d.ts

@@ -3,21 +3,17 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
  * XiaoYi Channel Plugin for OpenClaw
  *
  * This plugin enables integration with XiaoYi's A2A protocol via WebSocket.
+ * Single account mode only.
  *
  * Configuration example in openclaw.json:
  * {
  *   "channels": {
  *     "xiaoyi": {
  *       "enabled": true,
- *       "accounts": {
- *         "default": {
- *           "enabled": true,
- *           "wsUrl": "wss://hag.com/ws/link",
- *           "ak": "your-access-key",
- *           "sk": "your-secret-key",
- *           "agentId": "your-agent-id"
- *         }
- *       }
+ *       "wsUrl": "ws://localhost:8765/ws/link",
+ *       "ak": "test_ak",
+ *       "sk": "test_sk",
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }

package/dist/index.js

@@ -7,21 +7,17 @@ const runtime_1 = require("./runtime");
  * XiaoYi Channel Plugin for OpenClaw
  *
  * This plugin enables integration with XiaoYi's A2A protocol via WebSocket.
+ * Single account mode only.
  *
  * Configuration example in openclaw.json:
  * {
  *   "channels": {
  *     "xiaoyi": {
  *       "enabled": true,
- *       "accounts": {
- *         "default": {
- *           "enabled": true,
- *           "wsUrl": "wss://hag.com/ws/link",
- *           "ak": "your-access-key",
- *           "sk": "your-secret-key",
- *           "agentId": "your-agent-id"
- *         }
- *       }
+ *       "wsUrl": "ws://localhost:8765/ws/link",
+ *       "ak": "test_ak",
+ *       "sk": "test_sk",
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }

package/dist/runtime.d.ts

@@ -1,12 +1,14 @@
 import { XiaoYiWebSocketManager } from "./websocket";
-import { XiaoYiAccountConfig } from "./types";
+import { XiaoYiChannelConfig } from "./types";
 /**
  * Runtime state for XiaoYi channel
- * Manages WebSocket connections for each account
+ * Manages single WebSocket connection (single account mode)
  */
 export declare class XiaoYiRuntime {
-    private connections;
+    private connection;
     private runtime;
+    private config;
+    private sessionToTaskIdMap;
     /**
      * Set OpenClaw runtime
      */
@@ -16,33 +18,49 @@ export declare class XiaoYiRuntime {
      */
     getRuntime(): any;
     /**
-     * Start account connection
+     * Start connection (single account mode)
      */
-    startAccount(accountId: string, config: XiaoYiAccountConfig): Promise<void>;
+    start(config: XiaoYiChannelConfig): Promise<void>;
     /**
-     * Stop account connection
+     * Stop connection
      */
-    stopAccount(accountId: string): void;
+    stop(): void;
     /**
-     * Get WebSocket manager for account
+     * Get WebSocket manager
      */
-    getConnection(accountId: string): XiaoYiWebSocketManager | undefined;
+    getConnection(): XiaoYiWebSocketManager | null;
     /**
-     * Check if account is connected
+     * Check if connected
      */
-    isAccountConnected(accountId: string): boolean;
+    isConnected(): boolean;
     /**
-     * Get all connected account IDs
+     * Get configuration
      */
-    getConnectedAccounts(): string[];
+    getConfig(): XiaoYiChannelConfig | null;
     /**
-     * Stop all accounts
+     * Set taskId for a session
      */
-    stopAll(): void;
+    setTaskIdForSession(sessionId: string, taskId: string): void;
+    /**
+     * Get taskId for a session
+     */
+    getTaskIdForSession(sessionId: string): string | undefined;
+    /**
+     * Clear taskId for a session
+     */
+    clearTaskIdForSession(sessionId: string): void;
     /**
      * Handle incoming A2A message
      */
     private handleIncomingMessage;
+    /**
+     * Handle clear event
+     */
+    private handleClearEvent;
+    /**
+     * Handle cancel event
+     */
+    private handleCancelEvent;
 }
 export declare function getXiaoYiRuntime(): XiaoYiRuntime;
 export declare function setXiaoYiRuntime(runtime: any): void;

package/dist/runtime.js

@@ -6,12 +6,14 @@ exports.setXiaoYiRuntime = setXiaoYiRuntime;
 const websocket_1 = require("./websocket");
 /**
  * Runtime state for XiaoYi channel
- * Manages WebSocket connections for each account
+ * Manages single WebSocket connection (single account mode)
  */
 class XiaoYiRuntime {
     constructor() {
-        this.connections = new Map();
+        this.connection = null;
         this.runtime = null;
+        this.config = null;
+        this.sessionToTaskIdMap = new Map(); // Map sessionId to taskId
     }
     /**
      * Set OpenClaw runtime
@@ -26,78 +28,95 @@ class XiaoYiRuntime {
         return this.runtime;
     }
     /**
-     * Start account connection
+     * Start connection (single account mode)
      */
-    async startAccount(accountId, config) {
-        if (this.connections.has(accountId)) {
-            console.log(`Account ${accountId} already connected`);
+    async start(config) {
+        if (this.connection) {
+            console.log("XiaoYi channel already connected");
             return;
         }
+        this.config = config;
         const manager = new websocket_1.XiaoYiWebSocketManager(config);
         // Setup event handlers
         manager.on("message", (message) => {
-            this.handleIncomingMessage(accountId, message);
+            this.handleIncomingMessage(message);
         });
         manager.on("error", (error) => {
-            console.error(`XiaoYi account ${accountId} error:`, error);
+            console.error("XiaoYi channel error:", error);
         });
         manager.on("disconnected", () => {
-            console.log(`XiaoYi account ${accountId} disconnected`);
+            console.log("XiaoYi channel disconnected");
         });
         manager.on("authenticated", () => {
-            console.log(`XiaoYi account ${accountId} authenticated`);
+            console.log("XiaoYi channel authenticated");
+        });
+        manager.on("clear", (data) => {
+            this.handleClearEvent(data);
+        });
+        manager.on("cancel", (data) => {
+            this.handleCancelEvent(data);
         });
         manager.on("maxReconnectAttemptsReached", () => {
-            console.error(`XiaoYi account ${accountId} max reconnect attempts reached`);
-            this.stopAccount(accountId);
+            console.error("XiaoYi channel max reconnect attempts reached");
+            this.stop();
         });
         // Connect
         await manager.connect();
-        this.connections.set(accountId, manager);
-        console.log(`XiaoYi account ${accountId} started`);
+        this.connection = manager;
+        console.log("XiaoYi channel started");
     }
     /**
-     * Stop account connection
+     * Stop connection
      */
-    stopAccount(accountId) {
-        const manager = this.connections.get(accountId);
-        if (manager) {
-            manager.disconnect();
-            this.connections.delete(accountId);
-            console.log(`XiaoYi account ${accountId} stopped`);
+    stop() {
+        if (this.connection) {
+            this.connection.disconnect();
+            this.connection = null;
+            console.log("XiaoYi channel stopped");
         }
+        // Clear session mappings
+        this.sessionToTaskIdMap.clear();
     }
     /**
-     * Get WebSocket manager for account
+     * Get WebSocket manager
      */
-    getConnection(accountId) {
-        return this.connections.get(accountId);
+    getConnection() {
+        return this.connection;
     }
     /**
-     * Check if account is connected
+     * Check if connected
      */
-    isAccountConnected(accountId) {
-        const manager = this.connections.get(accountId);
-        return manager ? manager.isReady() : false;
+    isConnected() {
+        return this.connection ? this.connection.isReady() : false;
     }
     /**
-     * Get all connected account IDs
+     * Get configuration
      */
-    getConnectedAccounts() {
-        return Array.from(this.connections.keys()).filter((accountId) => this.isAccountConnected(accountId));
+    getConfig() {
+        return this.config;
     }
     /**
-     * Stop all accounts
+     * Set taskId for a session
      */
-    stopAll() {
-        for (const accountId of this.connections.keys()) {
-            this.stopAccount(accountId);
-        }
+    setTaskIdForSession(sessionId, taskId) {
+        this.sessionToTaskIdMap.set(sessionId, taskId);
+    }
+    /**
+     * Get taskId for a session
+     */
+    getTaskIdForSession(sessionId) {
+        return this.sessionToTaskIdMap.get(sessionId);
+    }
+    /**
+     * Clear taskId for a session
+     */
+    clearTaskIdForSession(sessionId) {
+        this.sessionToTaskIdMap.delete(sessionId);
     }
     /**
      * Handle incoming A2A message
      */
-    handleIncomingMessage(accountId, message) {
+    handleIncomingMessage(message) {
         if (!this.runtime) {
             console.error("Runtime not set, cannot handle message");
             return;
@@ -105,10 +124,31 @@ class XiaoYiRuntime {
         // Dispatch message to OpenClaw's message handling system
         // This will be called by the channel plugin's gateway adapter
         this.runtime.emit("xiaoyi:message", {
-            accountId,
             message,
         });
     }
+    /**
+     * Handle clear event
+     */
+    handleClearEvent(data) {
+        if (!this.runtime) {
+            console.error("Runtime not set, cannot handle clear event");
+            return;
+        }
+        // Emit clear event for OpenClaw to handle
+        this.runtime.emit("xiaoyi:clear", data);
+    }
+    /**
+     * Handle cancel event
+     */
+    handleCancelEvent(data) {
+        if (!this.runtime) {
+            console.error("Runtime not set, cannot handle cancel event");
+            return;
+        }
+        // Emit cancel event for OpenClaw to handle
+        this.runtime.emit("xiaoyi:cancel", data);
+    }
 }
 exports.XiaoYiRuntime = XiaoYiRuntime;
 // Global runtime instance

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 export interface A2ARequestMessage {
+    agentId: string;
     sessionId: string;
+    id: string;
     messageId: string;
     timestamp: number;
     sender: {
@@ -54,11 +56,30 @@ export interface A2AWebSocketMessage {
     type: "message" | "heartbeat" | "auth" | "error";
     data: A2ARequestMessage | A2AResponseMessage | any;
 }
-export interface XiaoYiChannelConfig {
-    enabled: boolean;
-    accounts: Record<string, XiaoYiAccountConfig>;
+export type OutboundMessageType = "clawd_bot_init" | "agent_response" | "heartbeat";
+export interface OutboundWebSocketMessage {
+    msgType: OutboundMessageType;
+    agentId: string;
+    sessionId?: string;
+    taskId?: string;
+    msgDetail?: string;
 }
-export interface XiaoYiAccountConfig {
+export interface A2AClearMessage {
+    agentId: string;
+    sessionId: string;
+    id: string;
+    action: "clear";
+    timestamp: number;
+}
+export interface A2ATasksCancelMessage {
+    agentId: string;
+    sessionId: string;
+    id: string;
+    action: "tasks/cancel";
+    taskId: string;
+    timestamp: number;
+}
+export interface XiaoYiChannelConfig {
     enabled: boolean;
     wsUrl: string;
     ak: string;
@@ -75,6 +96,7 @@ export interface WebSocketConnectionState {
     connected: boolean;
     authenticated: boolean;
     lastHeartbeat: number;
+    lastAppHeartbeat: number;
     reconnectAttempts: number;
     maxReconnectAttempts: number;
 }

package/dist/websocket.d.ts

@@ -1,25 +1,35 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiAccountConfig } from "./types";
+import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig } from "./types";
 export declare class XiaoYiWebSocketManager extends EventEmitter {
     private ws;
     private auth;
     private config;
     private state;
-    private heartbeatInterval;
+    private protocolHeartbeatInterval;
+    private appHeartbeatInterval;
     private reconnectTimeout;
-    constructor(config: XiaoYiAccountConfig);
+    private activeTasks;
+    constructor(config: XiaoYiChannelConfig);
     /**
-     * Connect to XiaoYi WebSocket server
+     * Connect to XiaoYi WebSocket server with header authentication
      */
     connect(): Promise<void>;
     /**
      * Disconnect from WebSocket server
      */
     disconnect(): void;
+    /**
+     * Send clawd_bot_init message on connection/reconnection
+     */
+    private sendInitMessage;
     /**
      * Send A2A response message
      */
-    sendResponse(response: A2AResponseMessage): Promise<void>;
+    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string): Promise<void>;
+    /**
+     * Send generic outbound message
+     */
+    private sendMessage;
     /**
      * Check if connection is ready for sending messages
      */
@@ -37,27 +47,45 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      */
     private handleMessage;
     /**
-     * Type guard for A2A request messages
+     * Handle A2A clear message
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
      */
-    private isA2ARequestMessage;
+    private handleClearMessage;
+    /**
+     * Handle A2A tasks/cancel message
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     */
+    private handleTasksCancelMessage;
     /**
-     * Authenticate with the server
+     * Send tasks/cancel success response
      */
-    private authenticate;
+    sendCancelSuccessResponse(sessionId: string, taskId: string, requestId: string): Promise<void>;
     /**
-     * Start heartbeat mechanism
+     * Type guard for A2A request messages
+     */
+    private isA2ARequestMessage;
+    /**
+     * Start protocol-level heartbeat (ping/pong)
      */
-    private startHeartbeat;
+    private startProtocolHeartbeat;
     /**
-     * Handle heartbeat response
+     * Start application-level heartbeat
      */
-    private handleHeartbeat;
+    private startAppHeartbeat;
     /**
-     * Schedule reconnection attempt
+     * Schedule reconnection attempt with exponential backoff
      */
     private scheduleReconnect;
     /**
      * Clear all timers
      */
     private clearTimers;
+    /**
+     * Get active tasks
+     */
+    getActiveTasks(): Map<string, any>;
+    /**
+     * Remove task from active tasks
+     */
+    removeActiveTask(taskId: string): void;
 }

package/dist/websocket.js

@@ -11,38 +11,51 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     constructor(config) {
         super();
         this.ws = null;
-        this.heartbeatInterval = null;
+        this.protocolHeartbeatInterval = null;
+        this.appHeartbeatInterval = null;
         this.reconnectTimeout = null;
+        this.activeTasks = new Map(); // Track active tasks for cancellation
         this.config = config;
         this.auth = new auth_1.XiaoYiAuth(config.ak, config.sk, config.agentId);
         this.state = {
             connected: false,
             authenticated: false,
             lastHeartbeat: 0,
+            lastAppHeartbeat: 0,
             reconnectAttempts: 0,
-            maxReconnectAttempts: 10,
+            maxReconnectAttempts: 50, // Increased from 10 to 50
         };
     }
     /**
-     * Connect to XiaoYi WebSocket server
+     * Connect to XiaoYi WebSocket server with header authentication
      */
     async connect() {
         if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
             return;
         }
         try {
-            this.ws = new ws_1.default(this.config.wsUrl);
+            // Generate authentication headers
+            const authHeaders = this.auth.generateAuthHeaders();
+            // Create WebSocket connection with headers
+            this.ws = new ws_1.default(this.config.wsUrl, {
+                headers: authHeaders,
+            });
             this.setupWebSocketHandlers();
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     reject(new Error("Connection timeout"));
-                }, 10000);
+                }, 30000); // Increased timeout to 30 seconds
                 this.ws.once("open", () => {
                     clearTimeout(timeout);
                     this.state.connected = true;
+                    this.state.authenticated = true; // Authenticated via headers
                     this.state.reconnectAttempts = 0;
                     this.emit("connected");
-                    this.authenticate();
+                    // Send clawd_bot_init message
+                    this.sendInitMessage();
+                    // Start heartbeats
+                    this.startProtocolHeartbeat();
+                    this.startAppHeartbeat();
                     resolve();
                 });
                 this.ws.once("error", (error) => {
@@ -67,23 +80,51 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         this.state.connected = false;
         this.state.authenticated = false;
+        this.activeTasks.clear();
         this.emit("disconnected");
     }
+    /**
+     * Send clawd_bot_init message on connection/reconnection
+     */
+    sendInitMessage() {
+        const initMessage = {
+            msgType: "clawd_bot_init",
+            agentId: this.config.agentId,
+        };
+        this.sendMessage(initMessage);
+        console.log("Sent clawd_bot_init message");
+    }
     /**
      * Send A2A response message
      */
-    async sendResponse(response) {
+    async sendResponse(response, taskId, sessionId) {
         if (!this.isReady()) {
             throw new Error("WebSocket not ready");
         }
         const message = {
-            type: "message",
-            data: {
-                ...response,
-                agentId: this.config.agentId, // Add agentId to response
-            },
+            msgType: "agent_response",
+            agentId: this.config.agentId,
+            sessionId: sessionId,
+            taskId: taskId,
+            msgDetail: JSON.stringify(response),
         };
-        this.ws.send(JSON.stringify(message));
+        this.sendMessage(message);
+    }
+    /**
+     * Send generic outbound message
+     */
+    sendMessage(message) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            console.error("Cannot send message: WebSocket not open");
+            return;
+        }
+        try {
+            this.ws.send(JSON.stringify(message));
+        }
+        catch (error) {
+            console.error("Failed to send message:", error);
+            this.emit("error", error);
+        }
     }
     /**
      * Check if connection is ready for sending messages
@@ -137,64 +178,130 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * Handle incoming WebSocket messages
      */
     handleMessage(message) {
-        switch (message.type) {
-            case "message":
-                if (this.isA2ARequestMessage(message.data)) {
-                    this.emit("message", message.data);
-                }
-                break;
-            case "auth":
-                if (message.data.success) {
-                    this.state.authenticated = true;
-                    this.startHeartbeat();
-                    this.emit("authenticated");
-                }
-                else {
-                    this.emit("authError", message.data.error);
-                }
-                break;
-            case "heartbeat":
-                this.handleHeartbeat();
-                break;
-            case "error":
-                this.emit("error", new Error(message.data.message || "Unknown error"));
-                break;
-            default:
-                console.warn("Unknown message type:", message.type);
+        // Validate agentId
+        if (message.agentId && message.agentId !== this.config.agentId) {
+            console.warn(`Received message with mismatched agentId: ${message.agentId}, expected: ${this.config.agentId}. Discarding.`);
+            return;
+        }
+        // Check if it's a clear message
+        if (message.action === "clear") {
+            this.handleClearMessage(message);
+            return;
         }
+        // Check if it's a tasks/cancel message
+        if (message.action === "tasks/cancel") {
+            this.handleTasksCancelMessage(message);
+            return;
+        }
+        // Handle regular A2A request message
+        if (this.isA2ARequestMessage(message)) {
+            // Store task for potential cancellation
+            this.activeTasks.set(message.id, {
+                sessionId: message.sessionId,
+                timestamp: Date.now(),
+            });
+            this.emit("message", message);
+        }
+        else {
+            console.warn("Received unknown message format:", message);
+        }
+    }
+    /**
+     * Handle A2A clear message
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     */
+    handleClearMessage(message) {
+        console.log(`Received clear message for session: ${message.sessionId}`);
+        // Send success response according to A2A spec
+        const response = {
+            sessionId: message.sessionId,
+            messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            agentId: this.config.agentId,
+            sender: {
+                id: this.config.agentId,
+                name: "OpenClaw Agent",
+                type: "agent",
+            },
+            content: {
+                type: "text",
+                text: "Context cleared successfully",
+            },
+            status: "success",
+        };
+        // Send response
+        this.sendResponse(response, message.id, message.sessionId).catch(error => {
+            console.error("Failed to send clear response:", error);
+        });
+        // Emit clear event for application to handle
+        this.emit("clear", {
+            sessionId: message.sessionId,
+            id: message.id,
+        });
+    }
+    /**
+     * Handle A2A tasks/cancel message
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     */
+    handleTasksCancelMessage(message) {
+        console.log(`Received tasks/cancel message for task: ${message.taskId}`);
+        // Emit cancel event for application to handle
+        this.emit("cancel", {
+            sessionId: message.sessionId,
+            taskId: message.taskId,
+            id: message.id,
+        });
+        // Note: We'll send the success response after OpenClaw confirms cancellation
+        // This will be handled by the channel plugin
+    }
+    /**
+     * Send tasks/cancel success response
+     */
+    async sendCancelSuccessResponse(sessionId, taskId, requestId) {
+        const response = {
+            sessionId: sessionId,
+            messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            agentId: this.config.agentId,
+            sender: {
+                id: this.config.agentId,
+                name: "OpenClaw Agent",
+                type: "agent",
+            },
+            content: {
+                type: "text",
+                text: "Task cancelled successfully",
+            },
+            status: "success",
+        };
+        await this.sendResponse(response, requestId, sessionId);
+        // Remove from active tasks
+        this.activeTasks.delete(taskId);
     }
     /**
      * Type guard for A2A request messages
      */
     isA2ARequestMessage(data) {
         return data &&
+            typeof data.agentId === "string" &&
             typeof data.sessionId === "string" &&
+            typeof data.id === "string" &&
             typeof data.messageId === "string" &&
             typeof data.timestamp === "number" &&
             data.sender &&
             data.content;
     }
     /**
-     * Authenticate with the server
-     */
-    authenticate() {
-        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-            return;
-        }
-        const authMessage = this.auth.generateAuthMessage();
-        this.ws.send(JSON.stringify(authMessage));
-    }
-    /**
-     * Start heartbeat mechanism
+     * Start protocol-level heartbeat (ping/pong)
      */
-    startHeartbeat() {
-        this.heartbeatInterval = setInterval(() => {
+    startProtocolHeartbeat() {
+        this.protocolHeartbeatInterval = setInterval(() => {
             if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                 this.ws.ping();
                 // Check if we haven't received a pong in too long
                 const now = Date.now();
-                if (this.state.lastHeartbeat > 0 && now - this.state.lastHeartbeat > 60000) {
-                    console.warn("Heartbeat timeout, reconnecting...");
+                if (this.state.lastHeartbeat > 0 && now - this.state.lastHeartbeat > 90000) {
+                    console.warn("Protocol heartbeat timeout, reconnecting...");
                     this.disconnect();
                     this.scheduleReconnect();
                 }
@@ -202,13 +309,22 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }, 30000); // Send ping every 30 seconds
     }
     /**
-     * Handle heartbeat response
+     * Start application-level heartbeat
      */
-    handleHeartbeat() {
-        this.state.lastHeartbeat = Date.now();
+    startAppHeartbeat() {
+        this.appHeartbeatInterval = setInterval(() => {
+            if (this.isReady()) {
+                const heartbeatMessage = {
+                    msgType: "heartbeat",
+                    agentId: this.config.agentId,
+                };
+                this.sendMessage(heartbeatMessage);
+                this.state.lastAppHeartbeat = Date.now();
+            }
+        }, 20000); // Send application heartbeat every 20 seconds
     }
     /**
-     * Schedule reconnection attempt
+     * Schedule reconnection attempt with exponential backoff
      */
     scheduleReconnect() {
         if (this.state.reconnectAttempts >= this.state.maxReconnectAttempts) {
@@ -216,9 +332,10 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             this.emit("maxReconnectAttemptsReached");
             return;
         }
-        const delay = Math.min(1000 * Math.pow(2, this.state.reconnectAttempts), 30000);
+        // Exponential backoff with longer intervals: 2s, 4s, 8s, 16s, 32s, 60s (max)
+        const delay = Math.min(2000 * Math.pow(2, this.state.reconnectAttempts), 60000);
         this.state.reconnectAttempts++;
-        console.log(`Scheduling reconnect attempt ${this.state.reconnectAttempts} in ${delay}ms`);
+        console.log(`Scheduling reconnect attempt ${this.state.reconnectAttempts}/${this.state.maxReconnectAttempts} in ${delay}ms`);
         this.reconnectTimeout = setTimeout(async () => {
             try {
                 await this.connect();
@@ -233,14 +350,30 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * Clear all timers
      */
     clearTimers() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
+        if (this.protocolHeartbeatInterval) {
+            clearInterval(this.protocolHeartbeatInterval);
+            this.protocolHeartbeatInterval = null;
+        }
+        if (this.appHeartbeatInterval) {
+            clearInterval(this.appHeartbeatInterval);
+            this.appHeartbeatInterval = null;
         }
         if (this.reconnectTimeout) {
             clearTimeout(this.reconnectTimeout);
             this.reconnectTimeout = null;
         }
     }
+    /**
+     * Get active tasks
+     */
+    getActiveTasks() {
+        return new Map(this.activeTasks);
+    }
+    /**
+     * Remove task from active tasks
+     */
+    removeActiveTask(taskId) {
+        this.activeTasks.delete(taskId);
+    }
 }
 exports.XiaoYiWebSocketManager = XiaoYiWebSocketManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",