@ynhcj/xiaoyi 2.2.0 → 2.2.1

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
@@ -219,13 +220,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 +413,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",