@ynhcj/xiaoyi 2.5.6 → 2.5.7

package/dist/xy-config.d.ts

@@ -0,0 +1,18 @@
+import type { OpenClawConfig } from "openclaw/dist/plugin-sdk/index.js";
+import type { XiaoYiChannelConfig } from "./types.js";
+type ClawdbotConfig = OpenClawConfig;
+/**
+ * Resolve XiaoYi channel configuration from OpenClaw config.
+ */
+export declare function resolveXYConfig(cfg: ClawdbotConfig): XiaoYiChannelConfig;
+/**
+ * List XiaoYi channel account IDs.
+ * Single account mode - always returns ["default"].
+ */
+export declare function listXYAccountIds(cfg: ClawdbotConfig): string[];
+/**
+ * Get default XiaoYi channel account ID.
+ * Single account mode - always returns "default".
+ */
+export declare function getDefaultXYAccountId(cfg: ClawdbotConfig): string | undefined;
+export {};

package/dist/xy-config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveXYConfig = resolveXYConfig;
+exports.listXYAccountIds = listXYAccountIds;
+exports.getDefaultXYAccountId = getDefaultXYAccountId;
+/**
+ * Resolve XiaoYi channel configuration from OpenClaw config.
+ */
+function resolveXYConfig(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig) {
+        throw new Error("XiaoYi channel configuration not found");
+    }
+    return channelConfig;
+}
+/**
+ * List XiaoYi channel account IDs.
+ * Single account mode - always returns ["default"].
+ */
+function listXYAccountIds(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig || !channelConfig.enabled) {
+        return [];
+    }
+    return ["default"];
+}
+/**
+ * Get default XiaoYi channel account ID.
+ * Single account mode - always returns "default".
+ */
+function getDefaultXYAccountId(cfg) {
+    const channelConfig = cfg?.channels?.xiaoyi;
+    if (!channelConfig || !channelConfig.enabled) {
+        return undefined;
+    }
+    return "default";
+}

package/dist/xy-formatter.d.ts

@@ -0,0 +1,94 @@
+import type { XiaoYiChannelConfig, A2ACommand } from "./types.js";
+/**
+ * Parameters for sending an A2A response.
+ */
+export interface SendA2AResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text?: string;
+    append: boolean;
+    final: boolean;
+    files?: Array<{
+        fileName: string;
+        fileType: string;
+        fileId: string;
+    }>;
+}
+/**
+ * Send an A2A artifact update response.
+ */
+export declare function sendA2AResponse(params: SendA2AResponseParams): Promise<void>;
+/**
+ * Parameters for sending a reasoning text update (intermediate, streamed).
+ */
+export interface SendReasoningTextUpdateParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    append?: boolean;
+}
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+export declare function sendReasoningTextUpdate(params: SendReasoningTextUpdateParams): Promise<void>;
+/**
+ * Parameters for sending a status update.
+ */
+export interface SendStatusUpdateParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+export declare function sendStatusUpdate(params: SendStatusUpdateParams): Promise<void>;
+/**
+ * Parameters for sending a command.
+ */
+export interface SendCommandParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    command: A2ACommand;
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+export declare function sendCommand(params: SendCommandParams): Promise<void>;
+/**
+ * Parameters for sending a clearContext response.
+ */
+export interface SendClearContextResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    messageId: string;
+}
+/**
+ * Send a clearContext response.
+ */
+export declare function sendClearContextResponse(params: SendClearContextResponseParams): Promise<void>;
+/**
+ * Parameters for sending a tasks/cancel response.
+ */
+export interface SendTasksCancelResponseParams {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+}
+/**
+ * Send a tasks/cancel response.
+ */
+export declare function sendTasksCancelResponse(params: SendTasksCancelResponseParams): Promise<void>;

package/dist/xy-formatter.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendA2AResponse = sendA2AResponse;
+exports.sendReasoningTextUpdate = sendReasoningTextUpdate;
+exports.sendStatusUpdate = sendStatusUpdate;
+exports.sendCommand = sendCommand;
+exports.sendClearContextResponse = sendClearContextResponse;
+exports.sendTasksCancelResponse = sendTasksCancelResponse;
+// OpenClaw → A2A format conversion
+const uuid_1 = require("uuid");
+const xy_client_js_1 = require("./xy-client.js");
+const runtime_js_1 = require("./runtime.js");
+/**
+ * Send an A2A artifact update response.
+ */
+async function sendA2AResponse(params) {
+    const { config, sessionId, taskId, messageId, text, append, final, files } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build artifact update event
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final,
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [],
+        },
+    };
+    // Add text part (even if empty string, to maintain parts structure)
+    if (text !== undefined) {
+        artifact.artifact.parts.push({
+            kind: "text",
+            text,
+        });
+    }
+    // Add file parts if provided
+    if (files && files.length > 0) {
+        artifact.artifact.parts.push({
+            kind: "data",
+            data: { fileInfo: files },
+        });
+    }
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
+    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
+    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
+    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE]   - append: ${append}`);
+    log(`[A2A_RESPONSE]   - final: ${final}`);
+    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+}
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+async function sendReasoningTextUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, append = true } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final: false,
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [
+                {
+                    kind: "reasoningText",
+                    reasoningText: text,
+                },
+            ],
+        },
+    };
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[REASONING_TEXT] 📤 Sending reasoningText update: sessionId=${sessionId}, taskId=${taskId}, text.length=${text.length}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[REASONING_TEXT] ✅ Sent successfully`);
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+async function sendStatusUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, state } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build status update event following A2A protocol standard
+    const statusUpdate = {
+        taskId,
+        kind: "status-update",
+        final: false, // Status updates should not end the stream
+        status: {
+            message: {
+                role: "agent",
+                parts: [
+                    {
+                        kind: "text",
+                        text,
+                    },
+                ],
+            },
+            state,
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: statusUpdate,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
+    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - messageId: ${messageId}`);
+    log(`[A2A_STATUS]   - state: ${state}`);
+    log(`[A2A_STATUS]   - text: "${text}"`);
+    log(`[A2A_STATUS] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_STATUS] ✅ Status update sent successfully`);
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+async function sendCommand(params) {
+    const { config, sessionId, taskId, messageId, command } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build artifact update with command as data
+    // Wrap command in commands array as per protocol requirement
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append: false,
+        lastChunk: true,
+        final: false, // Commands are not final
+        artifact: {
+            artifactId: (0, uuid_1.v4)(),
+            parts: [
+                {
+                    kind: "data",
+                    data: {
+                        commands: [command],
+                    },
+                },
+            ],
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
+    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
+    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
+    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
+    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
+    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_COMMAND] ✅ Command sent successfully`);
+}
+/**
+ * Send a clearContext response.
+ */
+async function sendClearContextResponse(params) {
+    const { config, sessionId, messageId } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for clearContext
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            status: {
+                state: "cleared",
+            },
+        },
+        error: {
+            code: 0,
+            // Note: Using any to bypass type check as the response format differs from standard A2A types
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId: sessionId, // Use sessionId as taskId for clearContext
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent clearContext response: sessionId=${sessionId}`);
+}
+/**
+ * Send a tasks/cancel response.
+ */
+async function sendTasksCancelResponse(params) {
+    const { config, sessionId, taskId, messageId } = params;
+    const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for tasks/cancel
+    // Note: Using any to bypass type check as the response format differs from standard A2A types
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            id: taskId,
+            status: {
+                state: "canceled",
+            },
+        },
+        error: {
+            code: 0,
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
+}

package/dist/xy-monitor.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+export type MonitorXYOpts = {
+    config?: any;
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    accountId?: string;
+    setStatus?: (status: {
+        lastEventAt?: number;
+        lastInboundAt?: number;
+        connected?: boolean;
+    }) => void;
+};
+/**
+ * Monitor XY channel WebSocket connections.
+ * Keeps the connection alive until abortSignal is triggered.
+ */
+export declare function monitorXYProvider(opts?: MonitorXYOpts): Promise<void>;

package/dist/xy-monitor.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monitorXYProvider = monitorXYProvider;
+const xy_config_js_1 = require("./xy-config.js");
+const xy_client_js_1 = require("./xy-client.js");
+const xy_bot_js_1 = require("./xy-bot.js");
+/**
+ * Per-session serial queue that ensures messages from the same session are processed
+ * in arrival order while allowing different sessions to run concurrently.
+ * Following feishu/monitor.account.ts pattern.
+ */
+function createSessionQueue() {
+    const queues = new Map();
+    return (sessionId, task) => {
+        const prev = queues.get(sessionId) ?? Promise.resolve();
+        const next = prev.then(task, task);
+        queues.set(sessionId, next);
+        void next.finally(() => {
+            if (queues.get(sessionId) === next) {
+                queues.delete(sessionId);
+            }
+        });
+        return next;
+    };
+}
+/**
+ * Monitor XY channel WebSocket connections.
+ * Keeps the connection alive until abortSignal is triggered.
+ */
+async function monitorXYProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg) {
+        throw new Error("Config is required for XY monitor");
+    }
+    const runtime = opts.runtime;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const account = (0, xy_config_js_1.resolveXYConfig)(cfg);
+    if (!account.enabled) {
+        throw new Error(`XY account is disabled`);
+    }
+    const accountId = opts.accountId ?? "default";
+    // Create trackEvent function to report health to OpenClaw framework
+    const trackEvent = opts.setStatus
+        ? () => {
+            opts.setStatus({ lastEventAt: Date.now(), lastInboundAt: Date.now() });
+        }
+        : undefined;
+    // 🔍 Diagnose WebSocket managers before gateway start
+    // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    // diagnoseAllManagers();
+    // Get WebSocket manager (cached)
+    const wsManager = (0, xy_client_js_1.getXYWebSocketManager)(account);
+    // ✅ Set health event callback for heartbeat reporting
+    // This ensures OpenClaw's health-monitor sees activity and doesn't trigger stale-socket restarts
+    if (trackEvent) {
+        wsManager.setHealthEventCallback(trackEvent);
+    }
+    // Track logged servers to avoid duplicate logs
+    const loggedServers = new Set();
+    // Track active message processing to detect duplicates
+    const activeMessages = new Set();
+    // Create session queue for ordered message processing
+    const enqueue = createSessionQueue();
+    // Health check interval
+    let healthCheckInterval = null;
+    return new Promise((resolve, reject) => {
+        // Event handlers (defined early so they can be referenced in cleanup)
+        const messageHandler = (message, sessionId, serverId) => {
+            const messageKey = `${sessionId}::${message.id}`;
+            log(`[MONITOR-HANDLER] ####### messageHandler triggered: serverId=${serverId}, sessionId=${sessionId}, messageId=${message.id} #######`);
+            // ✅ Report health: received a message
+            trackEvent?.();
+            // Check for duplicate message handling
+            if (activeMessages.has(messageKey)) {
+                error(`[MONITOR-HANDLER] ⚠️ WARNING: Duplicate message detected! messageKey=${messageKey}, this may cause duplicate dispatchers!`);
+            }
+            activeMessages.add(messageKey);
+            log(`[MONITOR-HANDLER] 📝 Active messages count: ${activeMessages.size}, messageKey: ${messageKey}`);
+            const task = async () => {
+                try {
+                    log(`[MONITOR-HANDLER] 🚀 Starting handleXYMessage for messageKey=${messageKey}`);
+                    await (0, xy_bot_js_1.handleXYMessage)({
+                        cfg,
+                        runtime,
+                        message,
+                        accountId, // ✅ Pass accountId ("default")
+                    });
+                    log(`[MONITOR-HANDLER] ✅ Completed handleXYMessage for messageKey=${messageKey}`);
+                }
+                catch (err) {
+                    // ✅ Only log error, don't re-throw to prevent gateway restart
+                    error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
+                }
+                finally {
+                    // Remove from active messages when done
+                    activeMessages.delete(messageKey);
+                    log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
+                }
+            };
+            void enqueue(sessionId, task).catch((err) => {
+                // Error already logged in task, this is for queue failures
+                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                activeMessages.delete(messageKey);
+            });
+        };
+        const connectedHandler = (serverId) => {
+            if (!loggedServers.has(serverId)) {
+                log(`XY gateway: ${serverId} connected`);
+                loggedServers.add(serverId);
+            }
+            // ✅ Report health: connection established
+            trackEvent?.();
+            opts.setStatus?.({ connected: true });
+        };
+        const disconnectedHandler = (serverId) => {
+            console.warn(`XY gateway: ${serverId} disconnected`);
+            loggedServers.delete(serverId);
+            // ✅ Report disconnection status (only if all servers disconnected)
+            if (loggedServers.size === 0) {
+                opts.setStatus?.({ connected: false });
+            }
+        };
+        const errorHandler = (err, serverId) => {
+            error(`XY gateway: ${serverId} error: ${String(err)}`);
+        };
+        const cleanup = () => {
+            log("XY gateway: cleaning up...");
+            // Stop health check interval
+            if (healthCheckInterval) {
+                clearInterval(healthCheckInterval);
+                healthCheckInterval = null;
+                console.log("⏸️  Stopped periodic health check");
+            }
+            // Remove event handlers to prevent duplicate calls on gateway restart
+            wsManager.off("message", messageHandler);
+            wsManager.off("connected", connectedHandler);
+            wsManager.off("disconnected", disconnectedHandler);
+            wsManager.off("error", errorHandler);
+            // ✅ Remove manager from cache - this will also disconnect
+            // removeXYWebSocketManager internally calls manager.disconnect()
+            (0, xy_client_js_1.removeXYWebSocketManager)(account);
+            loggedServers.clear();
+            activeMessages.clear();
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+        };
+        const handleAbort = () => {
+            log("XY gateway: abort signal received, stopping");
+            cleanup();
+            log("XY gateway stopped");
+            resolve();
+        };
+        if (opts.abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        // Register event handlers (handlers are defined above in cleanup scope)
+        wsManager.on("message", messageHandler);
+        wsManager.on("connected", connectedHandler);
+        wsManager.on("disconnected", disconnectedHandler);
+        wsManager.on("error", errorHandler);
+        // Start periodic health check (every 5 minutes)
+        console.log("🏥 Starting periodic health check (every 5 minutes)...");
+        healthCheckInterval = setInterval(() => {
+            console.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
+            // diagnoseAllManagers();
+            // // Auto-cleanup orphan connections
+            // const cleaned = cleanupOrphanConnections();
+            // if (cleaned > 0) {
+            //   console.log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+            // }
+        }, 5 * 60 * 1000); // 5 minutes
+        // Connect to WebSocket servers
+        wsManager.connect()
+            .then(() => {
+            log("XY gateway: started successfully");
+        })
+            .catch((err) => {
+            // Connection failed but don't reject - continue monitoring for reconnection
+            error(`XY gateway: initial connection failed: ${String(err)}`);
+            // Still resolve successfully so plugin starts
+            resolve();
+        });
+    });
+}