@ynhcj/xiaoyi 2.2.1 → 2.2.2

package/dist/channel.js

@@ -50,6 +50,8 @@ exports.xiaoyiPlugin = {
                     config: {
                         enabled: false,
                         wsUrl: "",
+                        wsUrl1: "",
+                        wsUrl2: "",
                         ak: "",
                         sk: "",
                         agentId: "",
@@ -78,7 +80,10 @@ exports.xiaoyiPlugin = {
             }
             const config = account.config;
             // Check each field is a string and has content after trimming
-            const hasWsUrl = typeof config.wsUrl === 'string' && config.wsUrl.trim().length > 0;
+            // Support both old wsUrl and new wsUrl1/wsUrl2
+            const hasWsUrl = ((typeof config.wsUrl === 'string' && config.wsUrl.trim().length > 0) ||
+                (typeof config.wsUrl1 === 'string' && config.wsUrl1.trim().length > 0) ||
+                (typeof config.wsUrl2 === 'string' && config.wsUrl2.trim().length > 0));
             const hasAk = typeof config.ak === 'string' && config.ak.trim().length > 0;
             const hasSk = typeof config.sk === 'string' && config.sk.trim().length > 0;
             const hasAgentId = typeof config.agentId === 'string' && config.agentId.trim().length > 0;
@@ -91,13 +96,14 @@ exports.xiaoyiPlugin = {
             return "Channel is disabled in configuration";
         },
         unconfiguredReason: (account, cfg) => {
-            return "Missing required configuration: wsUrl, ak, sk, or agentId";
+            return "Missing required configuration: wsUrl/wsUrl1/wsUrl2, ak, sk, or agentId";
         },
         describeAccount: (account, cfg) => ({
             accountId: account.accountId,
             name: 'XiaoYi',
             enabled: account.enabled,
-            configured: Boolean(account.config?.wsUrl && account.config?.ak && account.config?.sk && account.config?.agentId),
+            configured: Boolean((account.config?.wsUrl || account.config?.wsUrl1 || account.config?.wsUrl2) &&
+                account.config?.ak && account.config?.sk && account.config?.agentId),
         }),
     },
     /**

package/dist/index.d.ts

@@ -3,20 +3,24 @@ 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.
+ * Supports dual server mode for high availability.
  *
  * Configuration example in openclaw.json:
  * {
  *   "channels": {
  *     "xiaoyi": {
  *       "enabled": true,
- *       "wsUrl": "ws://localhost:8765/ws/link",
+ *       "wsUrl1": "ws://localhost:8765/ws/link",
+ *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id"
+ *       "agentId": "your-agent-id",
+ *       "enableStreaming": true
  *     }
  *   }
  * }
+ *
+ * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 declare const plugin: {
     id: string;

package/dist/index.js

@@ -7,20 +7,24 @@ 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.
+ * Supports dual server mode for high availability.
  *
  * Configuration example in openclaw.json:
  * {
  *   "channels": {
  *     "xiaoyi": {
  *       "enabled": true,
- *       "wsUrl": "ws://localhost:8765/ws/link",
+ *       "wsUrl1": "ws://localhost:8765/ws/link",
+ *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id"
+ *       "agentId": "your-agent-id",
+ *       "enableStreaming": true
  *     }
  *   }
  * }
+ *
+ * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 const plugin = {
     id: "xiaoyi",

package/dist/types.d.ts

@@ -141,7 +141,9 @@ export interface A2ATasksCancelMessage {
 }
 export interface XiaoYiChannelConfig {
     enabled: boolean;
-    wsUrl: string;
+    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak: string;
     sk: string;
     agentId: string;
@@ -161,3 +163,20 @@ export interface WebSocketConnectionState {
     reconnectAttempts: number;
     maxReconnectAttempts: number;
 }
+export declare const DEFAULT_WS_URL_1 = "ws://localhost:8080/ws";
+export declare const DEFAULT_WS_URL_2 = "ws://localhost:8081/ws";
+export interface InternalWebSocketConfig {
+    wsUrl1: string;
+    wsUrl2: string;
+    agentId: string;
+    ak: string;
+    sk: string;
+    enableStreaming?: boolean;
+}
+export type ServerId = 'server1' | 'server2';
+export interface ServerConnectionState {
+    connected: boolean;
+    ready: boolean;
+    lastHeartbeat: number;
+    reconnectAttempts: number;
+}

package/dist/types.js

@@ -2,3 +2,7 @@
 // A2A Message Structure Types
 // Based on: https://developer.huawei.com/consumer/cn/doc/service/message-stream-0000002505761434
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WS_URL_2 = exports.DEFAULT_WS_URL_1 = void 0;
+// Dual server configuration
+exports.DEFAULT_WS_URL_1 = "ws://localhost:8080/ws";
+exports.DEFAULT_WS_URL_2 = "ws://localhost:8081/ws";

package/dist/websocket.d.ts

@@ -1,113 +1,119 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig } from "./types";
+import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState } from "./types";
 export declare class XiaoYiWebSocketManager extends EventEmitter {
-    private ws;
+    private ws1;
+    private ws2;
+    private state1;
+    private state2;
+    private sessionServerMap;
     private auth;
     private config;
-    private state;
-    private protocolHeartbeatInterval;
-    private appHeartbeatInterval;
-    private reconnectTimeout;
+    private heartbeatTimeout1?;
+    private heartbeatTimeout2?;
+    private appHeartbeatInterval?;
+    private reconnectTimeout1?;
+    private reconnectTimeout2?;
     private activeTasks;
     constructor(config: XiaoYiChannelConfig);
     /**
-     * Connect to XiaoYi WebSocket server with header authentication
+     * Resolve configuration with defaults and backward compatibility
      */
-    connect(): Promise<void>;
+    private resolveConfig;
     /**
-     * Disconnect from WebSocket server
+     * Connect to both WebSocket servers
      */
-    disconnect(): void;
+    connect(): Promise<void>;
     /**
-     * Send clawd_bot_init message on connection/reconnection
+     * Connect to server 1
      */
-    private sendInitMessage;
+    private connectToServer1;
     /**
-     * Send A2A response message (converts to JSON-RPC 2.0 format)
-     * This method is for regular agent responses only
-     * @param response - The response message
-     * @param taskId - The task ID
-     * @param sessionId - The session ID
-     * @param isFinal - Whether this is the final frame (default: true)
-     * @param append - Whether to append to previous content (default: false for complete content)
+     * Connect to server 2
      */
-    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string, isFinal?: boolean, append?: boolean): Promise<void>;
+    private connectToServer2;
     /**
-     * Send A2A clear context response (uses specific clear context format)
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     * Disconnect from all servers
      */
-    sendClearContextResponse(requestId: string, sessionId: string, success?: boolean): Promise<void>;
+    disconnect(): void;
     /**
-     * Send A2A tasks cancel response (uses specific cancel format)
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     * Send init message to specific server
      */
-    sendTasksCancelResponse(requestId: string, sessionId: string, success?: boolean): Promise<void>;
+    private sendInitMessage;
     /**
-     * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
-     * @param response - The response message
-     * @param taskId - The task ID
-     * @param isFinal - Whether this is the final frame (default: true)
-     * @param append - Whether to append to previous content (default: false)
+     * Setup WebSocket event handlers for specific server
      */
-    private convertToJsonRpcFormat;
+    private setupWebSocketHandlers;
     /**
-     * Send generic outbound message
+     * Handle incoming message from specific server
      */
-    private sendMessage;
+    private handleIncomingMessage;
     /**
-     * Check if connection is ready for sending messages
+     * Send A2A response message with automatic routing
      */
-    isReady(): boolean;
+    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string, isFinal?: boolean, append?: boolean): Promise<void>;
     /**
-     * Get current connection state
+     * Send clear context response to specific server
      */
-    getState(): WebSocketConnectionState;
+    sendClearContextResponse(requestId: string, sessionId: string, success?: boolean, targetServer?: ServerId): Promise<void>;
     /**
-     * Setup WebSocket event handlers
+     * Send tasks cancel response to specific server
      */
-    private setupWebSocketHandlers;
+    sendTasksCancelResponse(requestId: string, sessionId: string, success?: boolean, targetServer?: ServerId): Promise<void>;
     /**
-     * Handle incoming WebSocket messages
+     * Handle clearContext method
      */
-    private handleMessage;
+    private handleClearContext;
     /**
-     * Handle A2A clear message
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     * Handle clear message (legacy format)
      */
     private handleClearMessage;
     /**
-     * Handle A2A tasks/cancel message
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
-     *
-     * Simplified implementation similar to clearContext:
-     * 1. Send success response immediately
-     * 2. Emit cancel event for application to handle
+     * Handle tasks/cancel message
      */
     private handleTasksCancelMessage;
     /**
-     * Send tasks/cancel success response
+     * Convert A2AResponseMessage to JSON-RPC 2.0 format
      */
-    sendCancelSuccessResponse(sessionId: string, taskId: string, requestId: string): Promise<void>;
+    private convertToJsonRpcFormat;
     /**
-     * Type guard for A2A request messages (JSON-RPC 2.0 format)
+     * Check if at least one server is ready
      */
-    private isA2ARequestMessage;
+    isReady(): boolean;
+    /**
+     * Get combined connection state
+     */
+    getState(): WebSocketConnectionState;
     /**
-     * Start protocol-level heartbeat (ping/pong)
+     * Get individual server states
+     */
+    getServerStates(): {
+        server1: ServerConnectionState;
+        server2: ServerConnectionState;
+    };
+    /**
+     * Start protocol-level heartbeat for specific server
      */
     private startProtocolHeartbeat;
     /**
-     * Start application-level heartbeat
+     * Clear protocol heartbeat for specific server
+     */
+    private clearProtocolHeartbeat;
+    /**
+     * Start application-level heartbeat (shared across both servers)
      */
     private startAppHeartbeat;
     /**
-     * Schedule reconnection attempt with exponential backoff
+     * Schedule reconnection for specific server
      */
     private scheduleReconnect;
     /**
      * Clear all timers
      */
     private clearTimers;
+    /**
+     * Type guard for A2A request messages
+     */
+    private isA2ARequestMessage;
     /**
      * Get active tasks
      */
@@ -116,4 +122,12 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * Remove task from active tasks
      */
     removeActiveTask(taskId: string): void;
+    /**
+     * Get server for a specific session
+     */
+    getServerForSession(sessionId: string): ServerId | undefined;
+    /**
+     * Remove session mapping
+     */
+    removeSession(sessionId: string): void;
 }

package/dist/websocket.js

@@ -7,102 +7,315 @@ exports.XiaoYiWebSocketManager = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const auth_1 = require("./auth");
+const types_1 = require("./types");
 class XiaoYiWebSocketManager extends events_1.EventEmitter {
     constructor(config) {
         super();
-        this.ws = 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 = {
+        // ==================== Dual WebSocket Connections ====================
+        this.ws1 = null;
+        this.ws2 = null;
+        // ==================== Dual Server States ====================
+        this.state1 = {
             connected: false,
-            authenticated: false,
+            ready: false,
             lastHeartbeat: 0,
-            lastAppHeartbeat: 0,
-            reconnectAttempts: 0,
-            maxReconnectAttempts: 50, // Increased from 10 to 50
+            reconnectAttempts: 0
+        };
+        this.state2 = {
+            connected: false,
+            ready: false,
+            lastHeartbeat: 0,
+            reconnectAttempts: 0
         };
+        // ==================== Session → Server Mapping ====================
+        this.sessionServerMap = new Map();
+        // ==================== Active Tasks ====================
+        this.activeTasks = new Map();
+        // Resolve configuration with defaults and backward compatibility
+        this.config = this.resolveConfig(config);
+        this.auth = new auth_1.XiaoYiAuth(this.config.ak, this.config.sk, this.config.agentId);
+        console.log(`[WS Manager] Initialized with dual server:`);
+        console.log(`  Server 1: ${this.config.wsUrl1}`);
+        console.log(`  Server 2: ${this.config.wsUrl2}`);
     }
     /**
-     * Connect to XiaoYi WebSocket server with header authentication
+     * Resolve configuration with defaults and backward compatibility
+     */
+    resolveConfig(userConfig) {
+        // Backward compatibility: if wsUrl is provided but wsUrl1/wsUrl2 are not,
+        // use wsUrl for server1 and default for server2
+        let wsUrl1 = userConfig.wsUrl1;
+        let wsUrl2 = userConfig.wsUrl2;
+        if (!wsUrl1 && userConfig.wsUrl) {
+            wsUrl1 = userConfig.wsUrl;
+        }
+        // Apply defaults if not provided
+        if (!wsUrl1) {
+            console.warn(`[WS Manager] wsUrl1 not provided, using default: ${types_1.DEFAULT_WS_URL_1}`);
+            wsUrl1 = types_1.DEFAULT_WS_URL_1;
+        }
+        if (!wsUrl2) {
+            console.warn(`[WS Manager] wsUrl2 not provided, using default: ${types_1.DEFAULT_WS_URL_2}`);
+            wsUrl2 = types_1.DEFAULT_WS_URL_2;
+        }
+        return {
+            wsUrl1,
+            wsUrl2,
+            agentId: userConfig.agentId,
+            ak: userConfig.ak,
+            sk: userConfig.sk,
+            enableStreaming: userConfig.enableStreaming,
+        };
+    }
+    /**
+     * Connect to both WebSocket servers
      */
     async connect() {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            return;
+        console.log("[WS Manager] Connecting to both servers...");
+        const results = await Promise.allSettled([
+            this.connectToServer1(),
+            this.connectToServer2(),
+        ]);
+        // Check if at least one connection succeeded
+        const server1Success = results[0].status === 'fulfilled';
+        const server2Success = results[1].status === 'fulfilled';
+        if (!server1Success && !server2Success) {
+            console.error("[WS Manager] Failed to connect to both servers");
+            throw new Error("Failed to connect to both servers");
+        }
+        console.log(`[WS Manager] Connection results: Server1=${server1Success}, Server2=${server2Success}`);
+        // Start application-level heartbeat (only if at least one connection is ready)
+        if (this.state1.connected || this.state2.connected) {
+            this.startAppHeartbeat();
+        }
+    }
+    /**
+     * Connect to server 1
+     */
+    async connectToServer1() {
+        console.log(`[Server1] Connecting to ${this.config.wsUrl1}...`);
+        try {
+            const authHeaders = this.auth.generateAuthHeaders();
+            this.ws1 = new ws_1.default(this.config.wsUrl1, {
+                headers: authHeaders,
+            });
+            this.setupWebSocketHandlers(this.ws1, 'server1');
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
+                this.ws1.once("open", () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                this.ws1.once("error", (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+            });
+            this.state1.connected = true;
+            this.state1.ready = true;
+            this.state1.reconnectAttempts = 0;
+            console.log(`[Server1] Connected successfully`);
+            this.emit("connected", "server1");
+            // Send init message
+            this.sendInitMessage(this.ws1, 'server1');
+            // Start protocol heartbeat
+            this.startProtocolHeartbeat('server1');
+        }
+        catch (error) {
+            console.error(`[Server1] Connection failed:`, error);
+            this.state1.connected = false;
+            this.state1.ready = false;
+            this.emit("error", { serverId: 'server1', error });
+            throw error;
         }
+    }
+    /**
+     * Connect to server 2
+     */
+    async connectToServer2() {
+        console.log(`[Server2] Connecting to ${this.config.wsUrl2}...`);
         try {
-            // Generate authentication headers
             const authHeaders = this.auth.generateAuthHeaders();
-            // Create WebSocket connection with headers
-            this.ws = new ws_1.default(this.config.wsUrl, {
+            this.ws2 = new ws_1.default(this.config.wsUrl2, {
                 headers: authHeaders,
             });
-            this.setupWebSocketHandlers();
-            return new Promise((resolve, reject) => {
-                this.ws.once("open", () => {
-                    this.state.connected = true;
-                    this.state.authenticated = true; // Authenticated via headers
-                    this.state.reconnectAttempts = 0;
-                    this.emit("connected");
-                    // Send clawd_bot_init message
-                    this.sendInitMessage();
-                    // Start heartbeats
-                    this.startProtocolHeartbeat();
-                    this.startAppHeartbeat();
+            this.setupWebSocketHandlers(this.ws2, 'server2');
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
+                this.ws2.once("open", () => {
+                    clearTimeout(timeout);
                     resolve();
                 });
-                this.ws.once("error", (error) => {
+                this.ws2.once("error", (error) => {
+                    clearTimeout(timeout);
                     reject(error);
                 });
             });
+            this.state2.connected = true;
+            this.state2.ready = true;
+            this.state2.reconnectAttempts = 0;
+            console.log(`[Server2] Connected successfully`);
+            this.emit("connected", "server2");
+            // Send init message
+            this.sendInitMessage(this.ws2, 'server2');
+            // Start protocol heartbeat
+            this.startProtocolHeartbeat('server2');
         }
         catch (error) {
-            this.emit("error", error);
+            console.error(`[Server2] Connection failed:`, error);
+            this.state2.connected = false;
+            this.state2.ready = false;
+            this.emit("error", { serverId: 'server2', error });
             throw error;
         }
     }
     /**
-     * Disconnect from WebSocket server
+     * Disconnect from all servers
      */
     disconnect() {
+        console.log("[WS Manager] Disconnecting from all servers...");
         this.clearTimers();
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
+        if (this.ws1) {
+            this.ws1.close();
+            this.ws1 = null;
         }
-        this.state.connected = false;
-        this.state.authenticated = false;
+        if (this.ws2) {
+            this.ws2.close();
+            this.ws2 = null;
+        }
+        this.state1.connected = false;
+        this.state1.ready = false;
+        this.state2.connected = false;
+        this.state2.ready = false;
+        this.sessionServerMap.clear();
         this.activeTasks.clear();
         this.emit("disconnected");
     }
     /**
-     * Send clawd_bot_init message on connection/reconnection
+     * Send init message to specific server
      */
-    sendInitMessage() {
+    sendInitMessage(ws, serverId) {
         const initMessage = {
             msgType: "clawd_bot_init",
             agentId: this.config.agentId,
         };
-        this.sendMessage(initMessage);
-        console.log("Sent clawd_bot_init message");
+        try {
+            ws.send(JSON.stringify(initMessage));
+            console.log(`[${serverId}] Sent clawd_bot_init message`);
+        }
+        catch (error) {
+            console.error(`[${serverId}] Failed to send init message:`, error);
+        }
     }
     /**
-     * Send A2A response message (converts to JSON-RPC 2.0 format)
-     * This method is for regular agent responses only
-     * @param response - The response message
-     * @param taskId - The task ID
-     * @param sessionId - The session ID
-     * @param isFinal - Whether this is the final frame (default: true)
-     * @param append - Whether to append to previous content (default: false for complete content)
+     * Setup WebSocket event handlers for specific server
+     */
+    setupWebSocketHandlers(ws, serverId) {
+        ws.on("open", () => {
+            console.log(`[${serverId}] WebSocket opened`);
+        });
+        ws.on("message", (data) => {
+            this.handleIncomingMessage(data, serverId);
+        });
+        ws.on("close", (code, reason) => {
+            console.log(`[${serverId}] WebSocket closed: ${code} ${reason.toString()}`);
+            if (serverId === 'server1') {
+                this.state1.connected = false;
+                this.state1.ready = false;
+                this.clearProtocolHeartbeat('server1');
+            }
+            else {
+                this.state2.connected = false;
+                this.state2.ready = false;
+                this.clearProtocolHeartbeat('server2');
+            }
+            this.emit("disconnected", serverId);
+            this.scheduleReconnect(serverId);
+        });
+        ws.on("error", (error) => {
+            console.error(`[${serverId}] WebSocket error:`, error);
+            this.emit("error", { serverId, error });
+        });
+        ws.on("pong", () => {
+            if (serverId === 'server1') {
+                this.state1.lastHeartbeat = Date.now();
+            }
+            else {
+                this.state2.lastHeartbeat = Date.now();
+            }
+        });
+    }
+    /**
+     * Handle incoming message from specific server
+     */
+    handleIncomingMessage(data, sourceServer) {
+        try {
+            const message = JSON.parse(data.toString());
+            // Log received message
+            console.log("\n" + "=".repeat(80));
+            console.log(`[${sourceServer}] Received message:`);
+            console.log(JSON.stringify(message, null, 2));
+            console.log("=".repeat(80) + "\n");
+            // Validate agentId
+            if (message.agentId && message.agentId !== this.config.agentId) {
+                console.warn(`[${sourceServer}] Mismatched agentId: ${message.agentId}, expected: ${this.config.agentId}. Discarding.`);
+                return;
+            }
+            // Record session → server mapping
+            if (message.sessionId) {
+                this.sessionServerMap.set(message.sessionId, sourceServer);
+                console.log(`[MAP] Session ${message.sessionId} -> ${sourceServer}`);
+            }
+            // Handle special messages (clearContext, tasks/cancel)
+            if (message.method === "clearContext") {
+                this.handleClearContext(message, sourceServer);
+                return;
+            }
+            if (message.action === "clear") {
+                this.handleClearMessage(message, sourceServer);
+                return;
+            }
+            if (message.method === "tasks/cancel" || message.action === "tasks/cancel") {
+                this.handleTasksCancelMessage(message, sourceServer);
+                return;
+            }
+            // Handle regular A2A request
+            if (this.isA2ARequestMessage(message)) {
+                // Store task for potential cancellation
+                this.activeTasks.set(message.id, {
+                    sessionId: message.sessionId,
+                    timestamp: Date.now(),
+                });
+                // Emit with server info
+                this.emit("message", message);
+            }
+            else {
+                console.warn(`[${sourceServer}] Unknown message format`);
+            }
+        }
+        catch (error) {
+            console.error(`[${sourceServer}] Failed to parse message:`, error);
+            this.emit("error", { serverId: sourceServer, error });
+        }
+    }
+    /**
+     * Send A2A response message with automatic routing
      */
     async sendResponse(response, taskId, sessionId, isFinal = true, append = false) {
-        if (!this.isReady()) {
-            throw new Error("WebSocket not ready");
+        // Find which server this session belongs to
+        const targetServer = this.sessionServerMap.get(sessionId);
+        if (!targetServer) {
+            console.error(`[ROUTE] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot route response: unknown session ${sessionId}`);
+        }
+        // Get the corresponding WebSocket connection
+        const ws = targetServer === 'server1' ? this.ws1 : this.ws2;
+        const state = targetServer === 'server1' ? this.state1 : this.state2;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            console.error(`[ROUTE] ${targetServer} not connected for session ${sessionId}`);
+            throw new Error(`${targetServer} is not available`);
         }
-        // Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
+        // Convert to JSON-RPC format
         const jsonRpcResponse = this.convertToJsonRpcFormat(response, taskId, isFinal, append);
         const message = {
             msgType: "agent_response",
@@ -111,15 +324,28 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             taskId: taskId,
             msgDetail: JSON.stringify(jsonRpcResponse),
         };
-        this.sendMessage(message);
+        try {
+            ws.send(JSON.stringify(message));
+            console.log(`[ROUTE] Response sent to ${targetServer} for session ${sessionId} (isFinal=${isFinal}, append=${append})`);
+        }
+        catch (error) {
+            console.error(`[ROUTE] Failed to send to ${targetServer}:`, error);
+            throw error;
+        }
     }
     /**
-     * Send A2A clear context response (uses specific clear context format)
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     * Send clear context response to specific server
      */
-    async sendClearContextResponse(requestId, sessionId, success = true) {
-        if (!this.isReady()) {
-            throw new Error("WebSocket not ready");
+    async sendClearContextResponse(requestId, sessionId, success = true, targetServer) {
+        const serverId = targetServer || this.sessionServerMap.get(sessionId);
+        if (!serverId) {
+            console.error(`[CLEAR] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot send clear response: unknown session ${sessionId}`);
+        }
+        const ws = serverId === 'server1' ? this.ws1 : this.ws2;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            console.error(`[CLEAR] ${serverId} not connected`);
+            throw new Error(`${serverId} is not available`);
         }
         const jsonRpcResponse = {
             jsonrpc: "2.0",
@@ -129,13 +355,6 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                     state: success ? "cleared" : "failed"
                 }
             },
-            error: success ? {
-                code: 0,
-                message: ""
-            } : {
-                code: -1,
-                message: "Failed to clear context"
-            },
         };
         const message = {
             msgType: "agent_response",
@@ -144,39 +363,41 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             taskId: requestId,
             msgDetail: JSON.stringify(jsonRpcResponse),
         };
-        console.log("\n[CLEAR] Sending clearContext response:");
-        console.log(`  msgType: ${message.msgType}`);
-        console.log(`  agentId: ${message.agentId}`);
-        console.log(`  sessionId: ${message.sessionId}`);
-        console.log(`  taskId: ${message.taskId}`);
-        console.log(`  msgDetail: ${message.msgDetail}`);
-        console.log("");
-        this.sendMessage(message);
+        console.log(`\n[CLEAR] Sending clearContext response to ${serverId}:`);
+        console.log(`  sessionId: ${sessionId}`);
+        console.log(`  requestId: ${requestId}`);
+        console.log(`  success: ${success}\n`);
+        try {
+            ws.send(JSON.stringify(message));
+        }
+        catch (error) {
+            console.error(`[CLEAR] Failed to send to ${serverId}:`, error);
+            throw error;
+        }
     }
     /**
-     * Send A2A tasks cancel response (uses specific cancel format)
-     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     * Send tasks cancel response to specific server
      */
-    async sendTasksCancelResponse(requestId, sessionId, success = true) {
-        if (!this.isReady()) {
-            throw new Error("WebSocket not ready");
+    async sendTasksCancelResponse(requestId, sessionId, success = true, targetServer) {
+        const serverId = targetServer || this.sessionServerMap.get(sessionId);
+        if (!serverId) {
+            console.error(`[CANCEL] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot send cancel response: unknown session ${sessionId}`);
+        }
+        const ws = serverId === 'server1' ? this.ws1 : this.ws2;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            console.error(`[CANCEL] ${serverId} not connected`);
+            throw new Error(`${serverId} is not available`);
         }
         const jsonRpcResponse = {
             jsonrpc: "2.0",
             id: requestId,
             result: {
-                id: requestId, // 使用请求中的该字段返回
+                id: requestId,
                 status: {
                     state: success ? "canceled" : "failed"
                 }
             },
-            error: success ? {
-                code: 0,
-                message: ""
-            } : {
-                code: -1,
-                message: "Failed to cancel task"
-            },
         };
         const message = {
             msgType: "agent_response",
@@ -185,19 +406,68 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             taskId: requestId,
             msgDetail: JSON.stringify(jsonRpcResponse),
         };
-        this.sendMessage(message);
+        try {
+            ws.send(JSON.stringify(message));
+        }
+        catch (error) {
+            console.error(`[CANCEL] Failed to send to ${serverId}:`, error);
+            throw error;
+        }
     }
     /**
-     * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
-     * @param response - The response message
-     * @param taskId - The task ID
-     * @param isFinal - Whether this is the final frame (default: true)
-     * @param append - Whether to append to previous content (default: false)
+     * Handle clearContext method
+     */
+    handleClearContext(message, sourceServer) {
+        console.log(`[${sourceServer}] Received clearContext for session: ${message.sessionId}`);
+        this.sendClearContextResponse(message.id, message.sessionId, true, sourceServer)
+            .catch(error => console.error(`[${sourceServer}] Failed to send clearContext response:`, error));
+        this.emit("clear", {
+            sessionId: message.sessionId,
+            id: message.id,
+            serverId: sourceServer,
+        });
+        // Remove session mapping
+        this.sessionServerMap.delete(message.sessionId);
+    }
+    /**
+     * Handle clear message (legacy format)
+     */
+    handleClearMessage(message, sourceServer) {
+        console.log(`[${sourceServer}] Received clear message for session: ${message.sessionId}`);
+        this.sendClearContextResponse(message.id, message.sessionId, true, sourceServer)
+            .catch(error => console.error(`[${sourceServer}] Failed to send clear response:`, error));
+        this.emit("clear", {
+            sessionId: message.sessionId,
+            id: message.id,
+            serverId: sourceServer,
+        });
+        this.sessionServerMap.delete(message.sessionId);
+    }
+    /**
+     * Handle tasks/cancel message
+     */
+    handleTasksCancelMessage(message, sourceServer) {
+        const effectiveTaskId = message.taskId || message.id;
+        console.log("\n" + "=".repeat(60));
+        console.log(`[${sourceServer}] Received cancel request`);
+        console.log(`  Session: ${message.sessionId}`);
+        console.log(`  Task ID: ${effectiveTaskId}`);
+        console.log("=".repeat(60) + "\n");
+        this.sendTasksCancelResponse(message.id, message.sessionId, true, sourceServer)
+            .catch(error => console.error(`[${sourceServer}] Failed to send cancel response:`, error));
+        this.emit("cancel", {
+            sessionId: message.sessionId,
+            taskId: effectiveTaskId,
+            id: message.id,
+            serverId: sourceServer,
+        });
+        this.activeTasks.delete(effectiveTaskId);
+    }
+    /**
+     * Convert A2AResponseMessage to JSON-RPC 2.0 format
      */
     convertToJsonRpcFormat(response, taskId, isFinal = true, append = false) {
-        // Generate artifact ID
         const artifactId = `artifact_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        // Check if there's an error
         if (response.status === "error" && response.error) {
             return {
                 jsonrpc: "2.0",
@@ -208,7 +478,6 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 },
             };
         }
-        // Convert content to artifact parts
         const parts = [];
         if (response.content.type === "text" && response.content.text) {
             parts.push({
@@ -226,13 +495,12 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 },
             });
         }
-        // Create TaskArtifactUpdateEvent with configurable flags
         const artifactEvent = {
             taskId: taskId,
             kind: "artifact-update",
-            append: append, // Controls whether to append or replace content
-            lastChunk: isFinal, // Set based on isFinal parameter
-            final: isFinal, // Set based on isFinal parameter
+            append: append,
+            lastChunk: isFinal,
+            final: isFinal,
             artifact: {
                 artifactId: artifactId,
                 parts: parts,
@@ -245,266 +513,179 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         };
     }
     /**
-     * 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
+     * Check if at least one server is ready
      */
     isReady() {
-        return !!(this.state.connected && this.state.authenticated &&
-            this.ws && this.ws.readyState === ws_1.default.OPEN);
+        return (this.state1.ready && this.ws1?.readyState === ws_1.default.OPEN) ||
+            (this.state2.ready && this.ws2?.readyState === ws_1.default.OPEN);
     }
     /**
-     * Get current connection state
+     * Get combined connection state
      */
     getState() {
-        return { ...this.state };
+        const connected = this.state1.connected || this.state2.connected;
+        const authenticated = connected; // Auth via headers
+        return {
+            connected,
+            authenticated,
+            lastHeartbeat: Math.max(this.state1.lastHeartbeat, this.state2.lastHeartbeat),
+            lastAppHeartbeat: 0,
+            reconnectAttempts: Math.max(this.state1.reconnectAttempts, this.state2.reconnectAttempts),
+            maxReconnectAttempts: 50,
+        };
     }
     /**
-     * Setup WebSocket event handlers
+     * Get individual server states
      */
-    setupWebSocketHandlers() {
-        if (!this.ws)
-            return;
-        this.ws.on("open", () => {
-            console.log("XiaoYi WebSocket connected");
-        });
-        this.ws.on("message", (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                this.handleMessage(message);
-            }
-            catch (error) {
-                console.error("Failed to parse WebSocket message:", error);
-                this.emit("error", error);
-            }
-        });
-        this.ws.on("close", (code, reason) => {
-            console.log(`XiaoYi WebSocket closed: ${code} ${reason.toString()}`);
-            this.state.connected = false;
-            this.state.authenticated = false;
-            this.clearTimers();
-            this.emit("disconnected");
-            this.scheduleReconnect();
-        });
-        this.ws.on("error", (error) => {
-            console.error("XiaoYi WebSocket error:", error);
-            this.emit("error", error);
-        });
-        this.ws.on("pong", () => {
-            this.state.lastHeartbeat = Date.now();
-        });
+    getServerStates() {
+        return {
+            server1: { ...this.state1 },
+            server2: { ...this.state2 },
+        };
     }
     /**
-     * Handle incoming WebSocket messages
+     * Start protocol-level heartbeat for specific server
      */
-    handleMessage(message) {
-        // 打印完整的接收消息
-        console.log("\n" + "=".repeat(80));
-        console.log(`[XiaoYi WS] Received message from server:`);
-        console.log(JSON.stringify(message, null, 2));
-        console.log("=".repeat(80) + "\n");
-        // 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;
-        }
-        // Handle JSON-RPC 2.0 clearContext method (直接响应，不走 OpenClaw)
-        // Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
-        if (message.method === "clearContext") {
-            console.log(`[CLEAR] Received clearContext for session: ${message.sessionId}`);
-            // 直接返回成功响应
-            this.sendClearContextResponse(message.id, message.sessionId, true).catch(error => {
-                console.error("Failed to send clearContext response:", error);
-            });
-            // 可选：通知应用清除会话上下文
-            this.emit("clear", {
-                sessionId: message.sessionId,
-                id: message.id,
-            });
-            return;
-        }
-        // Check if it's a clear message (兼容旧格式)
-        if (message.action === "clear") {
-            this.handleClearMessage(message);
-            return;
-        }
-        // Check if it's a tasks/cancel message (支持 method 和 action 两种格式)
-        if (message.method === "tasks/cancel" || 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);
+    startProtocolHeartbeat(serverId) {
+        const interval = setInterval(() => {
+            const ws = serverId === 'server1' ? this.ws1 : this.ws2;
+            const state = serverId === 'server1' ? this.state1 : this.state2;
+            if (ws && ws.readyState === ws_1.default.OPEN) {
+                ws.ping();
+                const now = Date.now();
+                if (state.lastHeartbeat > 0 && now - state.lastHeartbeat > 90000) {
+                    console.warn(`[${serverId}] Heartbeat timeout, reconnecting...`);
+                    ws.close();
+                }
+            }
+        }, 30000);
+        if (serverId === 'server1') {
+            this.heartbeatTimeout1 = interval;
         }
         else {
-            console.warn("Received unknown message format:", message);
+            this.heartbeatTimeout2 = interval;
         }
     }
     /**
-     * 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 using the correct format
-        this.sendClearContextResponse(message.id, message.sessionId, true).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
-     *
-     * Simplified implementation similar to clearContext:
-     * 1. Send success response immediately
-     * 2. Emit cancel event for application to handle
-     */
-    handleTasksCancelMessage(message) {
-        // Use taskId if available, otherwise use id as the task identifier
-        const effectiveTaskId = message.taskId || message.id;
-        console.log(`\n============================================================`);
-        console.log(`XiaoYi: [CANCEL] Received cancel request`);
-        console.log(`  Session: ${message.sessionId}`);
-        console.log(`  Task ID: ${effectiveTaskId}`);
-        console.log(`  Message ID: ${message.id}`);
-        console.log(`===========================================================\n`);
-        // Send success response immediately (similar to clearContext)
-        this.sendTasksCancelResponse(message.id, message.sessionId, true).catch(error => {
-            console.error("Failed to send tasks/cancel response:", error);
-        });
-        // Emit cancel event for application to handle
-        // The application can decide how to handle the cancellation
-        this.emit("cancel", {
-            sessionId: message.sessionId,
-            taskId: effectiveTaskId,
-            id: message.id,
-        });
-        // Remove from active tasks
-        this.activeTasks.delete(effectiveTaskId);
-    }
-    /**
-     * Send tasks/cancel success response
-     */
-    async sendCancelSuccessResponse(sessionId, taskId, requestId) {
-        // Use the dedicated tasks cancel response method with correct format
-        await this.sendTasksCancelResponse(requestId, sessionId, true);
-        // Remove from active tasks
-        this.activeTasks.delete(taskId);
-    }
-    /**
-     * Type guard for A2A request messages (JSON-RPC 2.0 format)
+     * Clear protocol heartbeat for specific server
      */
-    isA2ARequestMessage(data) {
-        return data &&
-            typeof data.agentId === "string" &&
-            typeof data.sessionId === "string" &&
-            data.jsonrpc === "2.0" &&
-            typeof data.id === "string" &&
-            data.method === "message/stream" &&
-            data.params &&
-            typeof data.params.id === "string" &&
-            typeof data.params.sessionId === "string" &&
-            data.params.message &&
-            typeof data.params.message.role === "string" &&
-            Array.isArray(data.params.message.parts);
-    }
-    /**
-     * Start protocol-level heartbeat (ping/pong)
-     */
-    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 > 90000) {
-                    console.warn("Protocol heartbeat timeout, reconnecting...");
-                    this.disconnect();
-                    this.scheduleReconnect();
-                }
+    clearProtocolHeartbeat(serverId) {
+        const interval = serverId === 'server1' ? this.heartbeatTimeout1 : this.heartbeatTimeout2;
+        if (interval) {
+            clearInterval(interval);
+            if (serverId === 'server1') {
+                this.heartbeatTimeout1 = undefined;
+            }
+            else {
+                this.heartbeatTimeout2 = undefined;
             }
-        }, 30000); // Send ping every 30 seconds
+        }
     }
     /**
-     * Start application-level heartbeat
+     * Start application-level heartbeat (shared across both servers)
      */
     startAppHeartbeat() {
         this.appHeartbeatInterval = setInterval(() => {
-            if (this.isReady()) {
-                const heartbeatMessage = {
-                    msgType: "heartbeat",
-                    agentId: this.config.agentId,
-                };
-                this.sendMessage(heartbeatMessage);
-                this.state.lastAppHeartbeat = Date.now();
+            const heartbeatMessage = {
+                msgType: "heartbeat",
+                agentId: this.config.agentId,
+            };
+            // Send to all connected servers
+            if (this.ws1?.readyState === ws_1.default.OPEN) {
+                try {
+                    this.ws1.send(JSON.stringify(heartbeatMessage));
+                }
+                catch (error) {
+                    console.error('[Server1] Failed to send app heartbeat:', error);
+                }
             }
-        }, 20000); // Send application heartbeat every 20 seconds
+            if (this.ws2?.readyState === ws_1.default.OPEN) {
+                try {
+                    this.ws2.send(JSON.stringify(heartbeatMessage));
+                }
+                catch (error) {
+                    console.error('[Server2] Failed to send app heartbeat:', error);
+                }
+            }
+        }, 20000);
     }
     /**
-     * Schedule reconnection attempt with exponential backoff
+     * Schedule reconnection for specific server
      */
-    scheduleReconnect() {
-        if (this.state.reconnectAttempts >= this.state.maxReconnectAttempts) {
-            console.error("Max reconnection attempts reached");
-            this.emit("maxReconnectAttemptsReached");
+    scheduleReconnect(serverId) {
+        const state = serverId === 'server1' ? this.state1 : this.state2;
+        if (state.reconnectAttempts >= 50) {
+            console.error(`[${serverId}] Max reconnection attempts reached`);
+            this.emit("maxReconnectAttemptsReached", serverId);
             return;
         }
-        // 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}/${this.state.maxReconnectAttempts} in ${delay}ms`);
-        this.reconnectTimeout = setTimeout(async () => {
+        const delay = Math.min(2000 * Math.pow(2, state.reconnectAttempts), 60000);
+        state.reconnectAttempts++;
+        console.log(`[${serverId}] Scheduling reconnect attempt ${state.reconnectAttempts}/50 in ${delay}ms`);
+        const timeout = setTimeout(async () => {
             try {
-                await this.connect();
+                if (serverId === 'server1') {
+                    await this.connectToServer1();
+                }
+                else {
+                    await this.connectToServer2();
+                }
+                console.log(`[${serverId}] Reconnected successfully`);
             }
             catch (error) {
-                console.error("Reconnection failed:", error);
-                this.scheduleReconnect();
+                console.error(`[${serverId}] Reconnection failed:`, error);
+                this.scheduleReconnect(serverId);
             }
         }, delay);
+        if (serverId === 'server1') {
+            this.reconnectTimeout1 = timeout;
+        }
+        else {
+            this.reconnectTimeout2 = timeout;
+        }
     }
     /**
      * Clear all timers
      */
     clearTimers() {
-        if (this.protocolHeartbeatInterval) {
-            clearInterval(this.protocolHeartbeatInterval);
-            this.protocolHeartbeatInterval = null;
+        if (this.heartbeatTimeout1) {
+            clearInterval(this.heartbeatTimeout1);
+            this.heartbeatTimeout1 = undefined;
+        }
+        if (this.heartbeatTimeout2) {
+            clearInterval(this.heartbeatTimeout2);
+            this.heartbeatTimeout2 = undefined;
         }
         if (this.appHeartbeatInterval) {
             clearInterval(this.appHeartbeatInterval);
-            this.appHeartbeatInterval = null;
+            this.appHeartbeatInterval = undefined;
+        }
+        if (this.reconnectTimeout1) {
+            clearTimeout(this.reconnectTimeout1);
+            this.reconnectTimeout1 = undefined;
         }
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
+        if (this.reconnectTimeout2) {
+            clearTimeout(this.reconnectTimeout2);
+            this.reconnectTimeout2 = undefined;
         }
     }
+    /**
+     * Type guard for A2A request messages
+     */
+    isA2ARequestMessage(data) {
+        return data &&
+            typeof data.agentId === "string" &&
+            typeof data.sessionId === "string" &&
+            data.jsonrpc === "2.0" &&
+            typeof data.id === "string" &&
+            data.method === "message/stream" &&
+            data.params &&
+            typeof data.params.id === "string" &&
+            typeof data.params.sessionId === "string" &&
+            data.params.message &&
+            typeof data.params.message.role === "string" &&
+            Array.isArray(data.params.message.parts);
+    }
     /**
      * Get active tasks
      */
@@ -517,5 +698,17 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     removeActiveTask(taskId) {
         this.activeTasks.delete(taskId);
     }
+    /**
+     * Get server for a specific session
+     */
+    getServerForSession(sessionId) {
+        return this.sessionServerMap.get(sessionId);
+    }
+    /**
+     * Remove session mapping
+     */
+    removeSession(sessionId) {
+        this.sessionServerMap.delete(sessionId);
+    }
 }
 exports.XiaoYiWebSocketManager = XiaoYiWebSocketManager;

package/package.json

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