@ynhcj/xiaoyi 2.2.0 → 2.2.2

package/dist/channel.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.xiaoyiPlugin = void 0;
 const runtime_1 = require("./runtime");
+const file_handler_1 = require("./file-handler");
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
@@ -49,6 +50,8 @@ exports.xiaoyiPlugin = {
                     config: {
                         enabled: false,
                         wsUrl: "",
+                        wsUrl1: "",
+                        wsUrl2: "",
                         ak: "",
                         sk: "",
                         agentId: "",
@@ -77,7 +80,10 @@ exports.xiaoyiPlugin = {
             }
             const config = account.config;
             // Check each field is a string and has content after trimming
-            const hasWsUrl = typeof config.wsUrl === 'string' && config.wsUrl.trim().length > 0;
+            // Support both old wsUrl and new wsUrl1/wsUrl2
+            const hasWsUrl = ((typeof config.wsUrl === 'string' && config.wsUrl.trim().length > 0) ||
+                (typeof config.wsUrl1 === 'string' && config.wsUrl1.trim().length > 0) ||
+                (typeof config.wsUrl2 === 'string' && config.wsUrl2.trim().length > 0));
             const hasAk = typeof config.ak === 'string' && config.ak.trim().length > 0;
             const hasSk = typeof config.sk === 'string' && config.sk.trim().length > 0;
             const hasAgentId = typeof config.agentId === 'string' && config.agentId.trim().length > 0;
@@ -90,13 +96,14 @@ exports.xiaoyiPlugin = {
             return "Channel is disabled in configuration";
         },
         unconfiguredReason: (account, cfg) => {
-            return "Missing required configuration: wsUrl, ak, sk, or agentId";
+            return "Missing required configuration: wsUrl/wsUrl1/wsUrl2, ak, sk, or agentId";
         },
         describeAccount: (account, cfg) => ({
             accountId: account.accountId,
             name: 'XiaoYi',
             enabled: account.enabled,
-            configured: Boolean(account.config?.wsUrl && account.config?.ak && account.config?.sk && account.config?.agentId),
+            configured: Boolean((account.config?.wsUrl || account.config?.wsUrl1 || account.config?.wsUrl2) &&
+                account.config?.ak && account.config?.sk && account.config?.agentId),
         }),
     },
     /**
@@ -219,13 +226,68 @@ exports.xiaoyiPlugin = {
                     console.error("PluginRuntime not available");
                     return;
                 }
-                // Extract text content from parts array (ignore kind: "data" as per user request)
+                // Extract text, file, and image content from parts array
                 let bodyText = "";
+                let images = [];
+                let fileAttachments = [];
                 for (const part of message.params.message.parts) {
                     if (part.kind === "text" && part.text) {
+                        // Handle text content
                         bodyText += part.text;
                     }
-                    // TODO: Handle file parts if needed in the future
+                    else if (part.kind === "file" && part.file) {
+                        // Handle file content
+                        const { uri, mimeType, name } = part.file;
+                        if (!uri) {
+                            console.warn(`XiaoYi: File part without URI, skipping: ${name}`);
+                            continue;
+                        }
+                        try {
+                            // Handle image files
+                            if ((0, file_handler_1.isImageMimeType)(mimeType)) {
+                                console.log(`XiaoYi: Processing image file: ${name} (${mimeType})`);
+                                const imageContent = await (0, file_handler_1.extractImageFromUrl)(uri, {
+                                    maxBytes: 10000000, // 10MB
+                                    timeoutMs: 30000, // 30 seconds
+                                });
+                                images.push(imageContent);
+                                fileAttachments.push(`[图片: ${name}]`);
+                                console.log(`XiaoYi: Successfully processed image: ${name}`);
+                            }
+                            // Handle PDF files - extract as text for now
+                            else if ((0, file_handler_1.isPdfMimeType)(mimeType)) {
+                                console.log(`XiaoYi: Processing PDF file: ${name}`);
+                                // Note: PDF text extraction requires pdfjs-dist, for now just add a placeholder
+                                fileAttachments.push(`[PDF文件: ${name} - PDF内容提取需要额外配置]`);
+                                console.log(`XiaoYi: PDF file noted: ${name} (text extraction requires pdfjs-dist)`);
+                            }
+                            // Handle text-based files
+                            else if ((0, file_handler_1.isTextMimeType)(mimeType)) {
+                                console.log(`XiaoYi: Processing text file: ${name} (${mimeType})`);
+                                const textContent = await (0, file_handler_1.extractTextFromUrl)(uri, 5000000, 30000);
+                                bodyText += `\n\n[文件内容: ${name}]\n${textContent}`;
+                                fileAttachments.push(`[文件: ${name}]`);
+                                console.log(`XiaoYi: Successfully processed text file: ${name}`);
+                            }
+                            else {
+                                console.warn(`XiaoYi: Unsupported file type: ${mimeType}, name: ${name}`);
+                                fileAttachments.push(`[不支持的文件类型: ${name} (${mimeType})]`);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            console.error(`XiaoYi: Failed to process file ${name}: ${errorMsg}`);
+                            fileAttachments.push(`[文件处理失败: ${name} - ${errorMsg}]`);
+                        }
+                    }
+                    // Ignore kind: "data" as per user request
+                }
+                // Log summary of processed attachments
+                if (fileAttachments.length > 0) {
+                    console.log(`XiaoYi: Processed ${fileAttachments.length} file(s): ${fileAttachments.join(", ")}`);
+                }
+                if (images.length > 0) {
+                    console.log(`XiaoYi: Total ${images.length} image(s) extracted for AI processing`);
                 }
                 // Determine sender ID from role
                 const senderId = message.params.message.role === "user" ? "user" : message.agentId;
@@ -357,6 +419,7 @@ exports.xiaoyiPlugin = {
                                 }
                             },
                         } : undefined, // No replyOptions when streaming is disabled
+                        images: images.length > 0 ? images : undefined, // Pass images to AI processing
                     });
                 }
                 catch (error) {

package/dist/file-handler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Simple file and image handler for XiaoYi Channel
+ * Handles downloading and extracting content from URIs
+ */
+export interface InputImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface ImageLimits {
+    allowUrl: boolean;
+    allowedMimes: Set<string>;
+    maxBytes: number;
+    maxRedirects: number;
+    timeoutMs: number;
+}
+/**
+ * Extract image content from URL
+ */
+export declare function extractImageFromUrl(url: string, limits?: Partial<ImageLimits>): Promise<InputImageContent>;
+/**
+ * Extract text content from URL (for text-based files)
+ */
+export declare function extractTextFromUrl(url: string, maxBytes?: number, timeoutMs?: number): Promise<string>;
+/**
+ * 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;

package/dist/file-handler.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Simple file and image handler for XiaoYi Channel
+ * Handles downloading and extracting content from URIs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImageFromUrl = extractImageFromUrl;
+exports.extractTextFromUrl = extractTextFromUrl;
+exports.isImageMimeType = isImageMimeType;
+exports.isPdfMimeType = isPdfMimeType;
+exports.isTextMimeType = isTextMimeType;
+// Default limits
+const DEFAULT_IMAGE_MIMES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+const DEFAULT_MAX_BYTES = 10000000; // 10MB
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+const DEFAULT_MAX_REDIRECTS = 3;
+/**
+ * Fetch content from URL with basic 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);
+    }
+}
+/**
+ * Extract image content from URL
+ */
+async function extractImageFromUrl(url, limits) {
+    const finalLimits = {
+        allowUrl: limits?.allowUrl ?? true,
+        allowedMimes: limits?.allowedMimes ?? DEFAULT_IMAGE_MIMES,
+        maxBytes: limits?.maxBytes ?? DEFAULT_MAX_BYTES,
+        maxRedirects: limits?.maxRedirects ?? DEFAULT_MAX_REDIRECTS,
+        timeoutMs: limits?.timeoutMs ?? DEFAULT_TIMEOUT,
+    };
+    if (!finalLimits.allowUrl) {
+        throw new Error("URL sources are disabled");
+    }
+    const { buffer, mimeType } = await fetchFromUrl(url, finalLimits.maxBytes, finalLimits.timeoutMs);
+    if (!finalLimits.allowedMimes.has(mimeType)) {
+        throw new Error(`Unsupported image type: ${mimeType}`);
+    }
+    return {
+        type: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+    };
+}
+/**
+ * Extract text content from URL (for text-based files)
+ */
+async function extractTextFromUrl(url, maxBytes = 5000000, timeoutMs = 30000) {
+    const { buffer, mimeType } = await fetchFromUrl(url, maxBytes, timeoutMs);
+    // Only process text-based MIME types
+    const textMimes = ["text/plain", "text/markdown", "text/html", "text/csv", "application/json", "application/xml"];
+    if (!textMimes.some((tm) => mimeType.startsWith(tm) || mimeType === tm)) {
+        throw new Error(`Unsupported text type: ${mimeType}`);
+    }
+    // Try to decode as UTF-8
+    return buffer.toString("utf-8");
+}
+/**
+ * Check if a MIME type is an image
+ */
+function isImageMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    return DEFAULT_IMAGE_MIMES.has(mimeType.toLowerCase());
+}
+/**
+ * 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");
+}

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