@ynhcj/xiaoyi 0.0.1-beta

package/dist/xiaoyi-media.d.ts

@@ -0,0 +1,81 @@
+/**
+ * XiaoYi Media Handler - Downloads and saves media files locally
+ * Similar to clawdbot-feishu's media.ts approach
+ */
+type PluginRuntime = any;
+export interface DownloadedMedia {
+    path: string;
+    contentType: string;
+    placeholder: string;
+    fileName?: string;
+}
+export interface MediaDownloadOptions {
+    maxBytes?: number;
+    timeoutMs?: number;
+}
+/**
+ * Check if a MIME type is an image
+ */
+export declare function isImageMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is a PDF
+ */
+export declare function isPdfMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is text-based
+ */
+export declare function isTextMimeType(mimeType: string | undefined): boolean;
+/**
+ * Download and save media file to local disk
+ * This is the key function that follows clawdbot-feishu's approach
+ */
+export declare function downloadAndSaveMedia(runtime: PluginRuntime, uri: string, mimeType: string, fileName: string, options?: MediaDownloadOptions): Promise<DownloadedMedia>;
+/**
+ * Download and save multiple media files
+ */
+export declare function downloadAndSaveMediaList(runtime: PluginRuntime, files: Array<{
+    uri: string;
+    mimeType: string;
+    name: string;
+}>, options?: MediaDownloadOptions): Promise<DownloadedMedia[]>;
+/**
+ * Build media payload for inbound context
+ * Similar to clawdbot-feishu's buildFeishuMediaPayload()
+ */
+export declare function buildXiaoYiMediaPayload(mediaList: DownloadedMedia[]): {
+    MediaPath?: string;
+    MediaType?: string;
+    MediaUrl?: string;
+    MediaPaths?: string[];
+    MediaUrls?: string[];
+    MediaTypes?: string[];
+};
+/**
+ * Extract text from downloaded file for including in message body
+ */
+export declare function extractTextFromFile(path: string, mimeType: string): Promise<string | null>;
+/**
+ * Input image content type for AI processing
+ */
+export interface InputImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+/**
+ * Image download limits
+ */
+export interface ImageLimits {
+    maxBytes?: number;
+    timeoutMs?: number;
+}
+/**
+ * Extract image from URL and return base64 encoded data
+ */
+export declare function extractImageFromUrl(url: string, limits?: Partial<ImageLimits>): Promise<InputImageContent>;
+/**
+ * Extract text content from URL
+ * Supports text-based files (txt, md, json, xml, csv, etc.)
+ */
+export declare function extractTextFromUrl(url: string, maxBytes?: number, timeoutMs?: number): Promise<string>;
+export {};

package/dist/xiaoyi-media.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * XiaoYi Media Handler - Downloads and saves media files locally
+ * Similar to clawdbot-feishu's media.ts approach
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageMimeType = isImageMimeType;
+exports.isPdfMimeType = isPdfMimeType;
+exports.isTextMimeType = isTextMimeType;
+exports.downloadAndSaveMedia = downloadAndSaveMedia;
+exports.downloadAndSaveMediaList = downloadAndSaveMediaList;
+exports.buildXiaoYiMediaPayload = buildXiaoYiMediaPayload;
+exports.extractTextFromFile = extractTextFromFile;
+exports.extractImageFromUrl = extractImageFromUrl;
+exports.extractTextFromUrl = extractTextFromUrl;
+/**
+ * Download content from URL with validation
+ */
+async function fetchFromUrl(url, maxBytes, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: { "User-Agent": "XiaoYi-Channel/1.0" },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Check content-length header if available
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+            const size = parseInt(contentLength, 10);
+            if (size > maxBytes) {
+                throw new Error(`File too large: ${size} bytes (limit: ${maxBytes})`);
+            }
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.byteLength > maxBytes) {
+            throw new Error(`File too large: ${buffer.byteLength} bytes (limit: ${maxBytes})`);
+        }
+        // Detect MIME type
+        const contentType = response.headers.get("content-type");
+        const mimeType = contentType?.split(";")[0]?.trim() || "application/octet-stream";
+        return { buffer, mimeType };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Infer placeholder text based on MIME type
+ */
+function inferPlaceholder(mimeType) {
+    if (mimeType.startsWith("image/")) {
+        return "<media:image>";
+    }
+    else if (mimeType.startsWith("video/")) {
+        return "<media:video>";
+    }
+    else if (mimeType.startsWith("audio/")) {
+        return "<media:audio>";
+    }
+    else if (mimeType === "application/pdf") {
+        return "<media:document>";
+    }
+    else if (mimeType.startsWith("text/")) {
+        return "<media:text>";
+    }
+    else {
+        return "<media:document>";
+    }
+}
+/**
+ * Check if a MIME type is an image
+ */
+function isImageMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    const lower = mimeType.toLowerCase();
+    // Standard formats: image/jpeg, image/png, etc.
+    if (lower.startsWith("image/")) {
+        return true;
+    }
+    // Handle non-standard formats like "jpeg" instead of "image/jpeg"
+    // Extract subtype if format is "type/subtype", otherwise use whole string
+    const subtype = lower.includes("/") ? lower.split("/")[1] : lower;
+    const imageSubtypes = [
+        "jpeg", "jpg", "png", "gif", "webp", "bmp", "svg+xml", "svg"
+    ];
+    return imageSubtypes.includes(subtype);
+}
+/**
+ * Check if a MIME type is a PDF
+ */
+function isPdfMimeType(mimeType) {
+    return mimeType?.toLowerCase() === "application/pdf" || false;
+}
+/**
+ * Check if a MIME type is text-based
+ */
+function isTextMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    const lower = mimeType.toLowerCase();
+    return (lower.startsWith("text/") ||
+        lower === "application/json" ||
+        lower === "application/xml");
+}
+/**
+ * Download and save media file to local disk
+ * This is the key function that follows clawdbot-feishu's approach
+ */
+async function downloadAndSaveMedia(runtime, uri, mimeType, fileName, options) {
+    const maxBytes = options?.maxBytes ?? 30000000; // 30MB default
+    const timeoutMs = options?.timeoutMs ?? 60000; // 60 seconds default
+    console.log(`[XiaoYi Media] Downloading: ${fileName} (${mimeType}) from ${uri}`);
+    // Download the file
+    const { buffer, mimeType: detectedMimeType } = await fetchFromUrl(uri, maxBytes, timeoutMs);
+    // Use detected MIME type if provided type is generic
+    const finalMimeType = mimeType === "application/octet-stream" ? detectedMimeType : mimeType;
+    // Save to local disk using OpenClaw's core.media API
+    // This is the critical step - saves file locally and returns path
+    const saved = await runtime.channel.media.saveMediaBuffer(buffer, finalMimeType, "inbound", maxBytes, fileName);
+    console.log(`[XiaoYi Media] Saved to: ${saved.path}`);
+    return {
+        path: saved.path,
+        contentType: saved.contentType,
+        placeholder: inferPlaceholder(saved.contentType),
+        fileName,
+    };
+}
+/**
+ * Download and save multiple media files
+ */
+async function downloadAndSaveMediaList(runtime, files, options) {
+    const results = [];
+    for (const file of files) {
+        try {
+            const downloaded = await downloadAndSaveMedia(runtime, file.uri, file.mimeType, file.name, options);
+            results.push(downloaded);
+        }
+        catch (error) {
+            console.error(`[XiaoYi Media] Failed to download ${file.name}:`, error);
+            // Continue with other files
+        }
+    }
+    return results;
+}
+/**
+ * Build media payload for inbound context
+ * Similar to clawdbot-feishu's buildFeishuMediaPayload()
+ */
+function buildXiaoYiMediaPayload(mediaList) {
+    if (mediaList.length === 0) {
+        return {};
+    }
+    const first = mediaList[0];
+    const mediaPaths = mediaList.map((media) => media.path);
+    const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean);
+    return {
+        MediaPath: first?.path,
+        MediaType: first?.contentType,
+        MediaUrl: first?.path,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    };
+}
+/**
+ * Extract text from downloaded file for including in message body
+ */
+async function extractTextFromFile(path, mimeType) {
+    // For now, just return null - Agent can read file directly from path
+    // This could be enhanced to extract text from specific file types
+    return null;
+}
+/**
+ * Extract image from URL and return base64 encoded data
+ */
+async function extractImageFromUrl(url, limits) {
+    const maxBytes = limits?.maxBytes ?? 10000000; // 10MB default
+    const timeoutMs = limits?.timeoutMs ?? 30000; // 30 seconds default
+    const { buffer, mimeType } = await fetchFromUrl(url, maxBytes, timeoutMs);
+    // Validate it's an image MIME type
+    if (!isImageMimeType(mimeType)) {
+        throw new Error(`Unsupported image type: ${mimeType}`);
+    }
+    return {
+        type: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+    };
+}
+/**
+ * Extract text content from URL
+ * Supports text-based files (txt, md, json, xml, csv, etc.)
+ */
+async function extractTextFromUrl(url, maxBytes = 5000000, timeoutMs = 30000) {
+    const { buffer, mimeType } = await fetchFromUrl(url, maxBytes, timeoutMs);
+    // Check if it's a text-based MIME type
+    const textMimes = [
+        "text/plain",
+        "text/markdown",
+        "text/html",
+        "text/csv",
+        "application/json",
+        "application/xml",
+        "text/xml",
+    ];
+    const isTextFile = textMimes.some(tm => mimeType.startsWith(tm) || mimeType === tm);
+    if (!isTextFile) {
+        throw new Error(`Unsupported text type: ${mimeType}`);
+    }
+    return buffer.toString("utf-8");
+}

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;