@ynhcj/xiaoyi 2.2.1 → 2.2.3

package/dist/channel.js

@@ -3,6 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.xiaoyiPlugin = void 0;
 const runtime_1 = require("./runtime");
 const file_handler_1 = require("./file-handler");
+// Import agent event functions - will be resolved at runtime
+// Use dynamic require for compatibility
+let onAgentEvent = null;
+let registerAgentRunContext = null;
+try {
+    // Try to import from the built openclaw package
+    const agentEvents = require("openclaw/dist/infra/agent-events");
+    onAgentEvent = agentEvents.onAgentEvent;
+    registerAgentRunContext = agentEvents.registerAgentRunContext;
+    console.log("XiaoYi: [AGENT EVENT] Successfully imported agent event functions");
+}
+catch (error) {
+    console.warn("XiaoYi: [AGENT EVENT] Could not import agent event functions:", error);
+    console.warn("XiaoYi: [AGENT EVENT] Streaming will be disabled");
+}
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
@@ -50,6 +65,8 @@ exports.xiaoyiPlugin = {
                     config: {
                         enabled: false,
                         wsUrl: "",
+                        wsUrl1: "",
+                        wsUrl2: "",
                         ak: "",
                         sk: "",
                         agentId: "",
@@ -78,7 +95,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 +111,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),
         }),
     },
     /**
@@ -301,15 +322,18 @@ exports.xiaoyiPlugin = {
                     SenderId: senderId,
                     OriginatingChannel: "xiaoyi",
                 };
-                // Use the correct API to dispatch the message (streaming mode enabled)
+                // Use the correct API to dispatch the message (streaming via onAgentEvent)
                 try {
                     const streamingEnabled = resolvedAccount.config.enableStreaming === true;
+                    const hasAgentEventSupport = typeof onAgentEvent === "function";
                     console.log("\n" + "=".repeat(60));
                     console.log(`XiaoYi: [STREAMING] Starting message processing`);
                     console.log(`  Session: ${message.sessionId}`);
                     console.log(`  Task ID: ${message.params.id}`);
                     console.log(`  User input: ${bodyText.substring(0, 50)}${bodyText.length > 50 ? "..." : ""}`);
-                    console.log(`  Streaming: ${streamingEnabled ? "ENABLED" : "DISABLED (enableStreaming=false)"}`);
+                    console.log(`  Config Streaming: ${streamingEnabled ? "ENABLED" : "DISABLED"}`);
+                    console.log(`  Agent Event Support: ${hasAgentEventSupport ? "AVAILABLE" : "NOT AVAILABLE"}`);
+                    console.log(`  Effective Streaming: ${streamingEnabled && hasAgentEventSupport ? "ENABLED (via onAgentEvent)" : "DISABLED"}`);
                     console.log("=".repeat(60) + "\n");
                     // Track response state for streaming
                     let accumulatedText = "";
@@ -317,23 +341,147 @@ exports.xiaoyiPlugin = {
                     let frameCount = 0;
                     let partialCount = 0;
                     const startTime = Date.now();
+                    // Register agent event listener for streaming (NEW METHOD)
+                    let unsubscribeAgentEvents;
+                    let runId;
+                    let isCompleted = false;
+                    if (streamingEnabled && hasAgentEventSupport) {
+                        // Subscribe to agent events BEFORE dispatching the message
+                        unsubscribeAgentEvents = onAgentEvent((evt) => {
+                            if (isCompleted)
+                                return;
+                            // Get runId from first event
+                            if (!runId && evt.runId) {
+                                runId = evt.runId;
+                                console.log(`XiaoYi: [AGENT EVENT] Registered runId: ${runId}`);
+                            }
+                            // Only process events for this run
+                            if (runId && evt.runId !== runId)
+                                return;
+                            const elapsed = Date.now() - startTime;
+                            // Handle streaming text events
+                            if (evt.stream === "assistant" && typeof evt.data?.text === "string") {
+                                const newText = evt.data.text;
+                                if (!newText)
+                                    return;
+                                // Calculate delta text
+                                const previousLength = accumulatedText.length;
+                                accumulatedText = newText;
+                                const deltaText = newText.slice(previousLength);
+                                console.log(`\n>>> XiaoYi: [AGENT EVENT] Stream frame #${++partialCount} at ${elapsed}ms`);
+                                console.log(`    Run ID: ${evt.runId}`);
+                                console.log(`    Delta length: ${deltaText.length} chars`);
+                                console.log(`    Total length: ${newText.length} chars`);
+                                console.log(`    Delta content: "${deltaText}"`);
+                                // Send PARTIAL frame with delta content
+                                const partialResponse = {
+                                    sessionId: message.sessionId,
+                                    messageId: `partial_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                                    timestamp: Date.now(),
+                                    agentId: resolvedAccount.config.agentId,
+                                    sender: {
+                                        id: resolvedAccount.config.agentId,
+                                        name: "OpenClaw Agent",
+                                        type: "agent",
+                                    },
+                                    content: {
+                                        type: "text",
+                                        text: deltaText || newText,
+                                    },
+                                    status: "processing",
+                                };
+                                const conn = runtime.getConnection();
+                                if (conn) {
+                                    conn.sendResponse(partialResponse, taskId, message.sessionId, false, true)
+                                        .then(() => {
+                                        console.log(`    ✓ SENT (isFinal=false, append=true)\n`);
+                                    })
+                                        .catch((err) => {
+                                        console.error(`    ✗ Send failed: ${err}\n`);
+                                    });
+                                }
+                            }
+                            // Handle lifecycle events (completion/error)
+                            if (evt.stream === "lifecycle") {
+                                const phase = evt.data?.phase;
+                                if (phase === "end") {
+                                    isCompleted = true;
+                                    console.log("\n" + "-".repeat(60));
+                                    console.log(`XiaoYi: [AGENT EVENT] Lifecycle phase: end`);
+                                    console.log(`  Run ID: ${evt.runId}`);
+                                    console.log(`  Elapsed: ${elapsed}ms`);
+                                    console.log(`  Total frames: ${partialCount}`);
+                                    console.log(`  Final length: ${accumulatedText.length} chars`);
+                                    console.log("-".repeat(60) + "\n");
+                                    // Send FINAL frame
+                                    const response = {
+                                        sessionId: message.sessionId,
+                                        messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                                        timestamp: Date.now(),
+                                        agentId: resolvedAccount.config.agentId,
+                                        sender: {
+                                            id: resolvedAccount.config.agentId,
+                                            name: "OpenClaw Agent",
+                                            type: "agent",
+                                        },
+                                        content: {
+                                            type: "text",
+                                            text: accumulatedText,
+                                        },
+                                        status: "success",
+                                    };
+                                    const conn = runtime.getConnection();
+                                    if (conn) {
+                                        conn.sendResponse(response, taskId, message.sessionId, true, false)
+                                            .then(() => {
+                                            console.log(`✓ XiaoYi: FINAL frame sent (isFinal=true, append=false)\n`);
+                                        })
+                                            .catch((err) => {
+                                            console.error(`✗ Final send failed: ${err}\n`);
+                                        });
+                                    }
+                                    // Unsubscribe from events
+                                    if (unsubscribeAgentEvents) {
+                                        unsubscribeAgentEvents();
+                                        unsubscribeAgentEvents = undefined;
+                                    }
+                                }
+                                else if (phase === "error") {
+                                    isCompleted = true;
+                                    console.error(`XiaoYi: [AGENT EVENT] Error phase:`, evt.data?.error);
+                                    // Unsubscribe from events
+                                    if (unsubscribeAgentEvents) {
+                                        unsubscribeAgentEvents();
+                                        unsubscribeAgentEvents = undefined;
+                                    }
+                                }
+                            }
+                        });
+                        console.log(`XiaoYi: [AGENT EVENT] Listener registered for streaming`);
+                    }
+                    else if (streamingEnabled && !hasAgentEventSupport) {
+                        console.warn(`XiaoYi: [WARN] Streaming enabled but onAgentEvent not available, falling back to non-streaming mode`);
+                    }
                     await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: msgContext,
                         cfg: config,
                         dispatcherOptions: {
                             deliver: async (payload) => {
+                                // This is the fallback for when streaming is disabled
+                                if (streamingEnabled) {
+                                    // Streaming mode: deliver is handled by onAgentEvent
+                                    console.log(`XiaoYi: [DELIVER] Skipping (handled by onAgentEvent)`);
+                                    return;
+                                }
                                 const elapsed = Date.now() - startTime;
                                 const completeText = payload.text || "";
                                 accumulatedText = completeText;
                                 console.log("\n" + "-".repeat(60));
-                                console.log(`XiaoYi: [STREAMING] DELIVER callback triggered`);
+                                console.log(`XiaoYi: [DELIVER] Non-streaming mode`);
                                 console.log(`  Elapsed: ${elapsed}ms`);
-                                console.log(`  Frame: #${++frameCount}`);
-                                console.log(`  Total length: ${completeText.length} chars`);
-                                console.log(`  Partial frames sent: ${partialCount}`);
-                                console.log(`  Content preview: ${completeText.substring(0, 100)}...`);
+                                console.log(`  Length: ${completeText.length} chars`);
                                 console.log("-".repeat(60) + "\n");
-                                // Send FINAL frame with complete content
+                                // Send final frame
                                 const response = {
                                     sessionId: message.sessionId,
                                     messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
@@ -346,74 +494,34 @@ exports.xiaoyiPlugin = {
                                     },
                                     content: {
                                         type: "text",
-                                        text: accumulatedText, // Complete content
+                                        text: accumulatedText,
                                     },
                                     status: "success",
                                 };
                                 const conn = runtime.getConnection();
                                 if (conn) {
-                                    // Use append=false for final frame (complete content)
                                     await conn.sendResponse(response, taskId, message.sessionId, true, false);
-                                    console.log(`✓ XiaoYi: FINAL frame sent (isFinal=true, append=false, length=${accumulatedText.length})\n`);
+                                    console.log(`✓ XiaoYi: FINAL frame sent (non-streaming)\n`);
                                 }
                             },
                             onIdle: async () => {
                                 const elapsed = Date.now() - startTime;
                                 console.log("\n" + "=".repeat(60));
-                                console.log(`XiaoYi: [STREAMING] Processing complete`);
+                                console.log(`XiaoYi: [IDLE] Processing complete`);
                                 console.log(`  Total time: ${elapsed}ms`);
-                                console.log(`  Total frames: ${frameCount}`);
-                                console.log(`  Partial frames: ${partialCount}`);
+                                console.log(`  Streaming frames: ${partialCount}`);
                                 console.log(`  Final length: ${accumulatedText.length} chars`);
                                 console.log("=".repeat(60) + "\n");
-                            },
-                        },
-                        replyOptions: streamingEnabled ? {
-                            // Enable streaming responses through onPartialReply callback
-                            disableBlockStreaming: false, // CRITICAL: Enable block streaming
-                            onPartialReply: async (payload) => {
-                                const elapsed = Date.now() - startTime;
-                                const newText = payload.text || "";
-                                if (!newText) {
-                                    console.log(`XiaoYi: [STREAMING] Skipping empty partial response at ${elapsed}ms`);
-                                    return;
-                                }
-                                // Calculate delta text (增量部分)
-                                const previousLength = accumulatedText.length;
-                                accumulatedText = newText;
-                                const deltaText = newText.slice(previousLength);
-                                console.log(`\n>>> XiaoYi: [PARTIAL] Frame #${++partialCount} at ${elapsed}ms`);
-                                console.log(`    Previous length: ${previousLength}`);
-                                console.log(`    New length: ${newText.length}`);
-                                console.log(`    Delta length: ${deltaText.length}`);
-                                console.log(`    Delta content: "${deltaText}"`);
-                                console.log(`    Accumulated so far: "${newText}"`);
-                                // Send PARTIAL frame with delta content
-                                const partialResponse = {
-                                    sessionId: message.sessionId,
-                                    messageId: `partial_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                                    timestamp: Date.now(),
-                                    agentId: resolvedAccount.config.agentId,
-                                    sender: {
-                                        id: resolvedAccount.config.agentId,
-                                        name: "OpenClaw Agent",
-                                        type: "agent",
-                                    },
-                                    content: {
-                                        type: "text",
-                                        text: deltaText || newText, // Send delta only (or full if delta is empty)
-                                    },
-                                    status: "processing", // Mark as processing
-                                };
-                                const conn = runtime.getConnection();
-                                if (conn) {
-                                    // Use append=true for streaming frames (服务端会追加)
-                                    await conn.sendResponse(partialResponse, taskId, message.sessionId, false, true);
-                                    console.log(`    ✓ SENT (isFinal=false, append=true)\n`);
+                                // Cleanup event listener if still active
+                                if (unsubscribeAgentEvents && !isCompleted) {
+                                    console.log(`XiaoYi: [IDLE] Cleaning up event listener`);
+                                    unsubscribeAgentEvents();
+                                    unsubscribeAgentEvents = undefined;
                                 }
                             },
-                        } : undefined, // No replyOptions when streaming is disabled
-                        images: images.length > 0 ? images : undefined, // Pass images to AI processing
+                        },
+                        replyOptions: undefined, // NOT using onPartialReply anymore
+                        images: images.length > 0 ? images : undefined,
                     });
                 }
                 catch (error) {

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;
 }