@ynhcj/xiaoyi 2.5.6 → 2.5.7

package/dist/websocket.js

@@ -7,8 +7,9 @@ exports.XiaoYiWebSocketManager = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const url_1 = require("url");
-const auth_1 = require("./auth");
-const types_1 = require("./types");
+const auth_js_1 = require("./auth.js");
+const heartbeat_js_1 = require("./heartbeat.js");
+const types_js_1 = require("./types.js");
 class XiaoYiWebSocketManager extends events_1.EventEmitter {
     constructor(config) {
         super();
@@ -37,11 +38,19 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         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);
+        this.auth = new auth_js_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}`);
     }
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     * This callback is invoked on heartbeat success to update lastEventAt.
+     */
+    setHealthEventCallback(callback) {
+        this.onHealthEvent = callback;
+        console.log("[WS Manager] Health event callback registered");
+    }
     /**
      * Check if URL is wss + IP format (skip certificate verification)
      */
@@ -96,12 +105,12 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         // 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;
+            console.warn(`[WS Manager] wsUrl1 not provided, using default: ${types_js_1.DEFAULT_WS_URL_1}`);
+            wsUrl1 = types_js_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;
+            console.warn(`[WS Manager] wsUrl2 not provided, using default: ${types_js_1.DEFAULT_WS_URL_2}`);
+            wsUrl2 = types_js_1.DEFAULT_WS_URL_2;
         }
         return {
             wsUrl1,
@@ -141,6 +150,22 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer1() {
         console.log(`[Server1] Connecting to ${this.config.wsUrl1}...`);
         try {
+            // ✅ Close existing connection and heartbeat before creating new one
+            if (this.ws1) {
+                console.log(`[Server1] Closing existing connection before reconnect`);
+                if (this.heartbeat1) {
+                    this.heartbeat1.stop();
+                    this.heartbeat1 = undefined;
+                }
+                try {
+                    this.ws1.removeAllListeners();
+                    this.ws1.close();
+                }
+                catch (err) {
+                    console.warn(`[Server1] Error closing old connection:`, err);
+                }
+                this.ws1 = null;
+            }
             const authHeaders = this.auth.generateAuthHeaders();
             // Check if URL is wss + IP format, skip certificate verification
             const skipCertVerify = this.isWssWithIp(this.config.wsUrl1);
@@ -151,6 +176,26 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 headers: authHeaders,
                 rejectUnauthorized: !skipCertVerify,
             });
+            // ✅ Initialize HeartbeatManager for server1
+            this.heartbeat1 = new heartbeat_js_1.HeartbeatManager(this.ws1, {
+                interval: 30000, // 30 seconds
+                timeout: 10000, // 10 seconds timeout
+                message: JSON.stringify({
+                    msgType: "heartbeat",
+                    agentId: this.config.agentId,
+                    timestamp: Date.now(),
+                }),
+            }, () => {
+                console.log(`[Server1] Heartbeat timeout, reconnecting...`);
+                if (this.ws1 && (this.ws1.readyState === ws_1.default.OPEN || this.ws1.readyState === ws_1.default.CONNECTING)) {
+                    this.ws1.close();
+                }
+            }, "server1", console.log, console.error, () => {
+                // ✅ Heartbeat success callback - report health to OpenClaw
+                this.emit("heartbeat", "server1");
+                // ✅ Report liveness to OpenClaw framework to prevent stale-socket detection
+                this.onHealthEvent?.();
+            });
             this.setupWebSocketHandlers(this.ws1, 'server1');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -171,8 +216,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             this.scheduleStableConnectionCheck('server1');
             // Send init message
             this.sendInitMessage(this.ws1, 'server1');
-            // Start protocol heartbeat
-            this.startProtocolHeartbeat('server1');
+            // ✅ Start heartbeat (replaces old startProtocolHeartbeat)
+            this.heartbeat1.start();
+            console.log(`[Server1] Heartbeat started (30s interval, 10s timeout)`);
         }
         catch (error) {
             console.error(`[Server1] Connection failed:`, error);
@@ -188,6 +234,22 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer2() {
         console.log(`[Server2] Connecting to ${this.config.wsUrl2}...`);
         try {
+            // ✅ Close existing connection and heartbeat before creating new one
+            if (this.ws2) {
+                console.log(`[Server2] Closing existing connection before reconnect`);
+                if (this.heartbeat2) {
+                    this.heartbeat2.stop();
+                    this.heartbeat2 = undefined;
+                }
+                try {
+                    this.ws2.removeAllListeners();
+                    this.ws2.close();
+                }
+                catch (err) {
+                    console.warn(`[Server2] Error closing old connection:`, err);
+                }
+                this.ws2 = null;
+            }
             const authHeaders = this.auth.generateAuthHeaders();
             // Check if URL is wss + IP format, skip certificate verification
             const skipCertVerify = this.isWssWithIp(this.config.wsUrl2);
@@ -198,6 +260,26 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 headers: authHeaders,
                 rejectUnauthorized: !skipCertVerify,
             });
+            // ✅ Initialize HeartbeatManager for server2
+            this.heartbeat2 = new heartbeat_js_1.HeartbeatManager(this.ws2, {
+                interval: 30000, // 30 seconds
+                timeout: 10000, // 10 seconds timeout
+                message: JSON.stringify({
+                    msgType: "heartbeat",
+                    agentId: this.config.agentId,
+                    timestamp: Date.now(),
+                }),
+            }, () => {
+                console.log(`[Server2] Heartbeat timeout, reconnecting...`);
+                if (this.ws2 && (this.ws2.readyState === ws_1.default.OPEN || this.ws2.readyState === ws_1.default.CONNECTING)) {
+                    this.ws2.close();
+                }
+            }, "server2", console.log, console.error, () => {
+                // ✅ Heartbeat success callback - report health to OpenClaw
+                this.emit("heartbeat", "server2");
+                // ✅ Report liveness to OpenClaw framework to prevent stale-socket detection
+                this.onHealthEvent?.();
+            });
             this.setupWebSocketHandlers(this.ws2, 'server2');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -218,8 +300,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             this.scheduleStableConnectionCheck('server2');
             // Send init message
             this.sendInitMessage(this.ws2, 'server2');
-            // Start protocol heartbeat
-            this.startProtocolHeartbeat('server2');
+            // ✅ Start heartbeat (replaces old startProtocolHeartbeat)
+            this.heartbeat2.start();
+            console.log(`[Server2] Heartbeat started (30s interval, 10s timeout)`);
         }
         catch (error) {
             console.error(`[Server2] Connection failed:`, error);
@@ -235,12 +318,42 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     disconnect() {
         console.log("[WS Manager] Disconnecting from all servers...");
         this.clearTimers();
+        // ✅ Stop heartbeat managers
+        if (this.heartbeat1) {
+            console.log("[Server1] Stopping heartbeat manager");
+            this.heartbeat1.stop();
+            this.heartbeat1 = undefined;
+        }
+        if (this.heartbeat2) {
+            console.log("[Server2] Stopping heartbeat manager");
+            this.heartbeat2.stop();
+            this.heartbeat2 = undefined;
+        }
+        // ✅ Properly cleanup WebSocket connections to prevent ghost connections
         if (this.ws1) {
-            this.ws1.close();
+            try {
+                console.log("[Server1] Removing all listeners and closing connection");
+                this.ws1.removeAllListeners();
+                if (this.ws1.readyState === ws_1.default.OPEN || this.ws1.readyState === ws_1.default.CONNECTING) {
+                    this.ws1.close();
+                }
+            }
+            catch (err) {
+                console.warn("[Server1] Error during disconnect:", err);
+            }
             this.ws1 = null;
         }
         if (this.ws2) {
-            this.ws2.close();
+            try {
+                console.log("[Server2] Removing all listeners and closing connection");
+                this.ws2.removeAllListeners();
+                if (this.ws2.readyState === ws_1.default.OPEN || this.ws2.readyState === ws_1.default.CONNECTING) {
+                    this.ws2.close();
+                }
+            }
+            catch (err) {
+                console.warn("[Server2] Error during disconnect:", err);
+            }
             this.ws2 = null;
         }
         this.state1.connected = false;
@@ -257,6 +370,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         this.sessionCleanupStateMap.clear();
         this.emit("disconnected");
+        console.log("[WS Manager] Disconnect complete");
     }
     /**
      * Send init message to specific server
@@ -560,6 +674,42 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         // TODO: Implement actual push message sending via HTTP API
         // Need to confirm correct push message format with XiaoYi API documentation
     }
+    /**
+     * Send an outbound WebSocket message directly.
+     * This is a low-level method that sends a pre-formatted OutboundWebSocketMessage.
+     *
+     * @param sessionId - Session ID for routing
+     * @param message - Pre-formatted outbound message
+     */
+    async sendMessage(sessionId, message) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            console.log(`[SEND_MESSAGE] Discarding message for pending cleanup session ${sessionId}`);
+            return;
+        }
+        // Find which server this session belongs to
+        const targetServer = this.sessionServerMap.get(sessionId);
+        if (!targetServer) {
+            console.error(`[SEND_MESSAGE] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot route message: 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(`[SEND_MESSAGE] ${targetServer} not connected for session ${sessionId}`);
+            throw new Error(`${targetServer} is not available`);
+        }
+        try {
+            ws.send(JSON.stringify(message));
+            console.log(`[SEND_MESSAGE] Message sent to ${targetServer} for session ${sessionId}, msgType=${message.msgType}`);
+        }
+        catch (error) {
+            console.error(`[SEND_MESSAGE] Failed to send to ${targetServer}:`, error);
+            throw error;
+        }
+    }
     /**
      * Send tasks cancel response to specific server
      */

package/dist/xy-bot.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+type ClawdbotConfig = OpenClawConfig;
+import type { A2AJsonRpcRequest } from "./types.js";
+/**
+ * Parameters for handling an XY message.
+ */
+export interface HandleXYMessageParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    message: A2AJsonRpcRequest;
+    accountId: string;
+}
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
+export {};

package/dist/xy-bot.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleXYMessage = handleXYMessage;
+const runtime_js_1 = require("./runtime.js");
+const xy_reply_dispatcher_js_1 = require("./xy-reply-dispatcher.js");
+const xy_parser_js_1 = require("./xy-parser.js");
+const file_download_js_1 = require("./file-download.js");
+const xy_config_js_1 = require("./xy-config.js");
+const xy_formatter_js_1 = require("./xy-formatter.js");
+const session_manager_js_1 = require("./xy-tools/session-manager.js");
+const config_manager_js_1 = require("./xy-utils/config-manager.js");
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+async function handleXYMessage(params) {
+    const { cfg, runtime, message, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Get OpenClaw PluginRuntime (not XiaoYiRuntime)
+    const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const core = xiaoYiRuntime.getPluginRuntime();
+    try {
+        // Check for special messages BEFORE parsing (these have different param structures)
+        const messageMethod = message.method;
+        log(`[BOT-ENTRY] <<<<<<< Received message with method: ${messageMethod}, id: ${message.id} >>>>>>>`);
+        log(`[BOT-ENTRY] Stack trace for debugging:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+        // Handle clearContext messages (params only has sessionId)
+        if (messageMethod === "clearContext" || messageMethod === "clear_context") {
+            const sessionId = message.params?.sessionId;
+            if (!sessionId) {
+                throw new Error("clearContext request missing sessionId in params");
+            }
+            log(`Clear context request for session ${sessionId}`);
+            const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+            await (0, xy_formatter_js_1.sendClearContextResponse)({
+                config,
+                sessionId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Handle tasks/cancel messages
+        if (messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
+            const sessionId = message.params?.sessionId;
+            const taskId = message.params?.id || message.id;
+            if (!sessionId) {
+                throw new Error("tasks/cancel request missing sessionId in params");
+            }
+            log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
+            const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+            await (0, xy_formatter_js_1.sendTasksCancelResponse)({
+                config,
+                sessionId,
+                taskId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Parse the A2A message (for regular messages)
+        const parsed = (0, xy_parser_js_1.parseA2AMessage)(message);
+        // Extract and update push_id if present
+        const pushId = (0, xy_parser_js_1.extractPushId)(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            config_manager_js_1.configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
+        // Resolve configuration (needed for status updates)
+        const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+        // ✅ Resolve agent route (following feishu pattern)
+        // accountId is "default" for XY (single account mode)
+        // Use sessionId as peer.id to ensure all messages in the same session share context
+        let route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "xiaoyi-channel",
+            accountId, // "default"
+            peer: {
+                kind: "direct",
+                id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
+            },
+        });
+        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        // Register session context for tools
+        log(`[BOT] 📝 About to register session for tools...`);
+        log(`[BOT]   - sessionKey: ${route.sessionKey}`);
+        log(`[BOT]   - sessionId: ${parsed.sessionId}`);
+        log(`[BOT]   - taskId: ${parsed.taskId}`);
+        (0, session_manager_js_1.registerSession)(route.sessionKey, {
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            agentId: route.accountId,
+        });
+        log(`[BOT] ✅ Session registered for tools`);
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void (0, xy_formatter_js_1.sendStatusUpdate)({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
+        // Extract text and files from parts
+        const text = (0, xy_parser_js_1.extractTextFromParts)(parsed.parts);
+        const fileParts = (0, xy_parser_js_1.extractFileParts)(parsed.parts);
+        // Download files if present (using core's media download)
+        const mediaList = await (0, file_download_js_1.downloadFilesFromParts)(fileParts);
+        // Build media payload for inbound context (following feishu pattern)
+        const mediaPayload = buildXYMediaPayload(mediaList);
+        // Resolve envelope format options (following feishu pattern)
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        // Build message body with speaker prefix (following feishu pattern)
+        let messageBody = text || "";
+        // Add speaker prefix for clarity
+        const speaker = parsed.sessionId;
+        messageBody = `${speaker}: ${messageBody}`;
+        // Format agent envelope (following feishu pattern)
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "xiaoyi-channel",
+            from: speaker,
+            timestamp: new Date(),
+            envelope: envelopeOptions,
+            body: messageBody,
+        });
+        // ✅ Finalize inbound context (following feishu pattern)
+        // Use route.accountId and route.sessionKey instead of parsed fields
+        const ctxPayload = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            RawBody: text || "",
+            CommandBody: text || "",
+            From: parsed.sessionId,
+            To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
+            SessionKey: route.sessionKey, // ✅ Use route.sessionKey
+            AccountId: route.accountId, // ✅ Use route.accountId ("default")
+            ChatType: "direct",
+            GroupSubject: undefined,
+            SenderName: parsed.sessionId,
+            SenderId: parsed.sessionId,
+            Provider: "xiaoyi-channel",
+            Surface: "xiaoyi-channel",
+            MessageSid: parsed.messageId,
+            Timestamp: Date.now(),
+            WasMentioned: false,
+            CommandAuthorized: true,
+            OriginatingChannel: "xiaoyi-channel",
+            OriginatingTo: parsed.sessionId, // Original message target
+            ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
+            ...mediaPayload,
+        });
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void (0, xy_formatter_js_1.sendStatusUpdate)({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
+        // Create reply dispatcher (following feishu pattern)
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
+        const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = (0, xy_reply_dispatcher_js_1.createXYReplyDispatcher)({
+            cfg,
+            runtime,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            accountId: route.accountId, // ✅ Use route.accountId
+        });
+        log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
+        // Start status update interval (will send updates every 60 seconds)
+        // Interval will be automatically stopped when onIdle/onCleanup is triggered
+        startStatusInterval();
+        log(`xy: dispatching to agent (session=${parsed.sessionId})`);
+        // Dispatch to OpenClaw core using correct API (following feishu pattern)
+        log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
+        await core.channel.reply.withReplyDispatcher({
+            dispatcher,
+            onSettled: () => {
+                log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                log(`[BOT]   - About to unregister session...`);
+                markDispatchIdle();
+                // Unregister session context when done
+                (0, session_manager_js_1.unregisterSession)(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered in onSettled`);
+            },
+            run: () => core.channel.reply.dispatchReplyFromConfig({
+                ctx: ctxPayload,
+                cfg,
+                dispatcher,
+                replyOptions,
+            }),
+        });
+        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
+        log(`xy: dispatch complete (session=${parsed.sessionId})`);
+    }
+    catch (err) {
+        // ✅ Only log error, don't re-throw to prevent gateway restart
+        error("Failed to handle XY message:", err);
+        runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
+        log(`[BOT] ❌ Error occurred, attempting cleanup...`);
+        // Try to unregister session on error (if route was established)
+        try {
+            const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+            const core = xiaoYiRuntime.getPluginRuntime();
+            const params = message.params;
+            const sessionId = params?.sessionId;
+            if (sessionId) {
+                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
+                const route = core.channel.routing.resolveAgentRoute({
+                    cfg,
+                    channel: "xiaoyi-channel",
+                    accountId,
+                    peer: {
+                        kind: "direct",
+                        id: sessionId, // ✅ Use sessionId for cleanup consistency
+                    },
+                });
+                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
+                (0, session_manager_js_1.unregisterSession)(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered after error`);
+            }
+        }
+        catch (cleanupErr) {
+            log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
+            // Ignore cleanup errors
+        }
+        // ❌ Don't re-throw: message processing error should not affect gateway stability
+    }
+}
+/**
+ * Build media payload for inbound context.
+ * Following feishu pattern: buildFeishuMediaPayload().
+ */
+function buildXYMediaPayload(mediaList) {
+    const first = mediaList[0];
+    const mediaPaths = mediaList.map((media) => media.path);
+    const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
+    return {
+        MediaPath: first?.path,
+        MediaType: first?.mimeType,
+        MediaUrl: first?.path,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    };
+}
+/**
+ * Infer OpenClaw media type from file type string.
+ */
+function inferMediaType(fileType) {
+    const lower = fileType.toLowerCase();
+    if (lower.includes("image") || /\.(jpg|jpeg|png|gif|bmp|webp)$/i.test(lower)) {
+        return "image";
+    }
+    if (lower.includes("video") || /\.(mp4|avi|mov|mkv|webm)$/i.test(lower)) {
+        return "video";
+    }
+    if (lower.includes("audio") || /\.(mp3|wav|ogg|m4a)$/i.test(lower)) {
+        return "audio";
+    }
+    return "file";
+}

package/dist/xy-client.d.ts

@@ -0,0 +1,26 @@
+import { XiaoYiWebSocketManager } from "./websocket.js";
+import type { XiaoYiChannelConfig } from "./types.js";
+import type { RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+/**
+ * Set the runtime for logging in client module.
+ */
+export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ * Adapted for xiaoyi - uses aksk instead of apiKey/uid
+ */
+export declare function getXYWebSocketManager(config: XiaoYiChannelConfig): XiaoYiWebSocketManager;
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export declare function removeXYWebSocketManager(config: XiaoYiChannelConfig): void;
+/**
+ * Clear all cached WebSocket managers.
+ */
+export declare function clearXYWebSocketManagers(): void;
+/**
+ * Get the number of cached managers.
+ */
+export declare function getCachedManagerCount(): number;

package/dist/xy-client.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setClientRuntime = setClientRuntime;
+exports.getXYWebSocketManager = getXYWebSocketManager;
+exports.removeXYWebSocketManager = removeXYWebSocketManager;
+exports.clearXYWebSocketManagers = clearXYWebSocketManagers;
+exports.getCachedManagerCount = getCachedManagerCount;
+// WebSocket client cache management
+// Adapted for xiaoyi - uses xiaoyi's WebSocket manager with aksk auth
+const websocket_js_1 = require("./websocket.js");
+// Runtime reference for logging
+let runtime;
+/**
+ * Set the runtime for logging in client module.
+ */
+function setClientRuntime(rt) {
+    runtime = rt;
+}
+/**
+ * Global cache for WebSocket managers.
+ * Key format: `${ak}-${agentId}` (using xiaoyi's aksk auth)
+ */
+const wsManagerCache = new Map();
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ * Adapted for xiaoyi - uses aksk instead of apiKey/uid
+ */
+function getXYWebSocketManager(config) {
+    const cacheKey = `${config.ak}-${config.agentId}`;
+    let cached = wsManagerCache.get(cacheKey);
+    if (cached) {
+        const log = runtime?.log ?? console.log;
+        log(`[WS-MANAGER-CACHE] ✅ Reusing cached WebSocket manager: ${cacheKey}, total managers: ${wsManagerCache.size}`);
+        return cached;
+    }
+    // Create new manager with xiaoyi's config (aksk auth)
+    const log = runtime?.log ?? console.log;
+    log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    cached = new websocket_js_1.XiaoYiWebSocketManager(config);
+    wsManagerCache.set(cacheKey, cached);
+    log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    return cached;
+}
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+function removeXYWebSocketManager(config) {
+    const cacheKey = `${config.ak}-${config.agentId}`;
+    const manager = wsManagerCache.get(cacheKey);
+    if (manager) {
+        console.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        manager.disconnect();
+        wsManagerCache.delete(cacheKey);
+        console.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+    }
+    else {
+        console.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+    }
+}
+/**
+ * Clear all cached WebSocket managers.
+ */
+function clearXYWebSocketManagers() {
+    const log = runtime?.log ?? console.log;
+    log("Clearing all WebSocket manager caches");
+    for (const manager of wsManagerCache.values()) {
+        manager.disconnect();
+    }
+    wsManagerCache.clear();
+}
+/**
+ * Get the number of cached managers.
+ */
+function getCachedManagerCount() {
+    return wsManagerCache.size;
+}