@chenchaolong/plugin-mineru-chen 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# MinerU Plugin
+
+## 简介
+
+MinerU 是一个将文件转换为机器可读格式（如 markdown、JSON）的工具，可以方便地提取为任意格式。
+
+MinerU 是一个文档解析器，可以解析复杂的文档数据，适用于任何下游 LLM 用例（RAG、智能体等）。
+
+[GitHub - opendatalab/MinerU](https://github.com/opendatalab/MinerU)
+
+## 主要特性
+
+- 移除页眉、页脚、脚注、页码等，确保语义连贯性
+- 以人类可读的顺序输出文本，适用于单列、多列和复杂布局
+- 保留原始文档的结构，包括标题、段落、列表等
+- 提取图片、图片描述、表格、表格标题和脚注
+- 自动识别并将文档中的公式转换为 LaTeX 格式
+- 自动识别并将文档中的表格转换为 HTML 格式
+- 自动检测扫描 PDF 和乱码 PDF 并启用 OCR 功能
+- OCR 支持检测和识别 84 种语言
+- 支持多种输出格式，如多模态和 NLP Markdown、按阅读顺序排序的 JSON，以及丰富的中间格式
+- 支持多种可视化结果，包括布局可视化和跨度可视化，用于高效确认输出质量
+- 支持在纯 CPU 环境中运行，也支持 GPU(CUDA)/NPU(CANN)/MPS 加速
+- 兼容 Windows、Linux 和 Mac 平台
+
+## 支持的输入文件类型
+
+**PDF, DOC, DOCX, PPT, PPTX, PNG, JPG, JPEG**
+
+## 使用方法
+
+### 配置步骤
+
+1. 配置 MinerU 插件参数：
+   - Base URL: MinerU API 服务的基础 URL（例如：`https://mineru.net`）
+   - Token: [从 MinerU 获取您的 API token](https://mineru.net/apiManage/token)
+
+2. 保存配置
+
+### 输入参数
+
+| 参数 | 类型 | 必填 | 示例 | 描述 |
+| :--- | :--- | :--- | :--- | :--- |
+| enable_formula | bool | 否 | true | 是否启用公式识别，默认为 true |
+| enable_table | bool | 否 | true | 是否启用表格识别，默认为 true |
+| language | string | 否 | ch | 指定文档语言，默认为 ch，可以设置为 auto，当为 auto 时，模型将自动识别文档语言，其他可选值列表请参见：[PaddleOCR](https://paddlepaddle.github.io/PaddleOCR/latest/ppocr/blog/multi_languages.html#5) |
+| enable_ocr | bool | 否 | false | 是否启动 OCR 功能，默认为 false |
+| extra_formats | [string] | 否 | ["docx","html"] | Markdown 和 json 是默认的导出格式，无需设置。此参数仅支持 docx、html、latex 三种格式中的一种或多种 |
+| model_version | string | 否 | pipeline | MinerU 模型版本；选项：pipeline 或 vlm，默认为 pipeline |
+
+### 输出
+
+插件为每个处理的文件提供以下输出：
+
+- **text**: 解析后的 Markdown 文本
+- **files**: 额外导出格式的文件（html、docx、latex）和提取的图片
+- **json**: 解析后的内容列表
+
+### 支持的导出格式
+
+默认情况下，插件会输出 Markdown 和 JSON 格式。通过 `extra_formats` 参数，还可以获取以下额外格式：
+
+- **HTML**: 格式化的 HTML 文档
+- **DOCX**: Microsoft Word 文档格式
+- **LaTeX**: LaTeX 源代码格式
+
+这些额外格式的文件将存储在输出的 `files` 中。
+
+## 技术细节
+
+### API 端点
+
+插件使用 MinerU 官方 API，主要端点包括：
+
+- `POST /api/v4/file-urls/batch`: 创建解析任务
+- `GET /api/v4/extract-results/batch/{batch_id}`: 获取解析结果
+
+### 处理流程
+
+1. 上传文件到 MinerU API 获取的上传 URL
+2. 创建解析任务
+3. 轮询获取解析结果
+4. 下载并解压 ZIP 文件
+5. 提取 Markdown、图片、JSON 等格式的内容
+6. 替换 Markdown 中的图片路径为可访问的 URL
+
+## 许可证
+
+请参考项目根目录的 LICENSE 文件。

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { XpertPlugin } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+declare const ConfigSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare const plugin: XpertPlugin<z.infer<typeof ConfigSchema>>;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAIvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAYvB,QAAA,MAAM,YAAY,gDAAe,CAAA;AAEjC,QAAA,MAAM,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CA4BrD,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { z } from 'zod';
+import { MinerUPlugin } from './lib/plugin.js';
+import { icon } from './lib/types.js';
+const __filename = fileURLToPath(import.meta.url);
+const dir_name = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(dir_name, '../package.json'), 'utf8'));
+const ConfigSchema = z.object({});
+const plugin = {
+    meta: {
+        name: packageJson.name,
+        version: packageJson.version,
+        category: 'tools',
+        icon: {
+            type: 'svg',
+            value: icon,
+        },
+        displayName: 'MinerU',
+        description: 'MinerU is a tool that converts FILES into machine-readable formats (e.g., markdown, JSON), allowing for easy extraction into any format.',
+        keywords: ['mineru', 'pdf', 'parser', 'document', 'markdown', 'json'],
+        author: 'XpertAI Team',
+    },
+    config: {
+        schema: ConfigSchema,
+    },
+    register(ctx) {
+        ctx.logger.log('register mineru plugin');
+        return { module: MinerUPlugin, global: true };
+    },
+    async onStart(ctx) {
+        ctx.logger.log('mineru plugin started');
+    },
+    async onStop(ctx) {
+        ctx.logger.log('mineru plugin stopped');
+    },
+};
+export default plugin;

package/dist/lib/parse.tool.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { Credentials } from './types.js';
+/**
+ * Build parse file tool
+ * @param credentials - MinerU API credentials (base_url and token)
+ */
+export declare function buildParseFileTool(credentials: Credentials): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    fileUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    filePath: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    file: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
+    content: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>]>>>;
+    enable_formula: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    enable_table: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    language: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    enable_ocr: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    extra_formats: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    model_version: z.ZodNullable<z.ZodOptional<z.ZodEnum<["pipeline", "vlm"]>>>;
+}, "strip", z.ZodTypeAny, {
+    filePath?: string;
+    fileUrl?: string;
+    file?: any;
+    content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: string;
+    enable_ocr?: boolean;
+    extra_formats?: string;
+    model_version?: "vlm" | "pipeline";
+}, {
+    filePath?: string;
+    fileUrl?: string;
+    file?: any;
+    content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: string;
+    enable_ocr?: boolean;
+    extra_formats?: string;
+    model_version?: "vlm" | "pipeline";
+}>, {
+    filePath?: string;
+    fileUrl?: string;
+    file?: any;
+    content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: string;
+    enable_ocr?: boolean;
+    extra_formats?: string;
+    model_version?: "vlm" | "pipeline";
+}, {
+    filePath?: string;
+    fileUrl?: string;
+    file?: any;
+    content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: string;
+    enable_ocr?: boolean;
+    extra_formats?: string;
+    model_version?: "vlm" | "pipeline";
+}, any[]>;
+//# sourceMappingURL=parse.tool.d.ts.map

package/dist/lib/parse.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.tool.d.ts","sourceRoot":"","sources":["../../src/lib/parse.tool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,EAAE,WAAW,EAAwF,MAAM,YAAY,CAAA;AA0V9H;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2K1D"}

package/dist/lib/parse.tool.js

@@ -0,0 +1,437 @@
+import { tool } from '@langchain/core/tools';
+import { getCurrentTaskInput } from '@langchain/langgraph';
+import { getErrorMessage } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import JSZip from 'jszip';
+import { SUPPORTED_EXTENSIONS, SUPPORTED_IMAGE_EXTENSIONS, MAX_RETRIES } from './types.js';
+/**
+ * Get MIME type based on file extension
+ */
+function getMimeType(fileName) {
+    const ext = path.extname(fileName).toLowerCase().slice(1);
+    const mimeTypes = {
+        pdf: 'application/pdf',
+        doc: 'application/msword',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        ppt: 'application/vnd.ms-powerpoint',
+        pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        md: 'text/markdown',
+        json: 'application/json',
+        html: 'text/html',
+        tex: 'application/x-tex',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+/**
+ * Build API URL by combining base URL with paths
+ */
+function buildApiUrl(baseUrl, ...paths) {
+    const url = new URL(baseUrl);
+    const pathParts = paths.filter(p => p).join('/');
+    if (pathParts) {
+        url.pathname = path.posix.join(url.pathname, pathParts);
+    }
+    return url.toString();
+}
+/**
+ * Get request headers for remote API
+ */
+function getHeaders(credentials) {
+    return {
+        Authorization: `Bearer ${credentials.token}`,
+        'Content-Type': 'application/json',
+    };
+}
+/**
+ * Validate file type
+ */
+function validateFileType(filename) {
+    const extension = path.extname(filename).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.includes(extension)) {
+        throw new Error(`File extension ${extension} is not supported. Supported extensions: ${SUPPORTED_EXTENSIONS.join(', ')}`);
+    }
+}
+/**
+ * Process base64 encoded image
+ */
+async function processBase64Image(encodedImageData, fileName, workspacePath, baseUrl) {
+    try {
+        // Extract base64 data (remove data:image/...;base64, prefix if present)
+        const base64Data = encodedImageData.includes(',')
+            ? encodedImageData.split(',')[1]
+            : encodedImageData;
+        const imageBytes = Buffer.from(base64Data, 'base64');
+        // Save image to workspace
+        const filePath = path.join(workspacePath, fileName);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, imageBytes);
+        const fileUrl = new URL(encodeURIComponent(fileName), baseUrl).href;
+        return {
+            mimeType: 'image/jpeg',
+            fileName,
+            filePath,
+            fileUrl,
+            extension: 'jpeg',
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to decode base64 image ${fileName}: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Replace image paths in Markdown content with file URLs
+ */
+function replaceMdImgPath(mdContent, images) {
+    let result = mdContent;
+    for (const image of images) {
+        if (image.fileUrl) {
+            result = result.replace(`images/${image.fileName}`, image.fileUrl);
+        }
+    }
+    return result;
+}
+/**
+ * Poll for parse result
+ */
+async function pollGetParseResult(credentials, batchId) {
+    const url = buildApiUrl(credentials.base_url, 'api/v4/extract-results/batch', batchId);
+    const headers = getHeaders(credentials);
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+            const response = await fetch(url, { headers });
+            if (!response.ok) {
+                if (attempt === MAX_RETRIES - 1) {
+                    throw new Error(`Failed to get parse result, status: ${response.status}`);
+                }
+                await new Promise(resolve => setTimeout(resolve, 5000));
+                continue;
+            }
+            const data = (await response.json());
+            const extractResults = data.data?.extract_result || [];
+            if (extractResults.length === 0) {
+                await new Promise(resolve => setTimeout(resolve, 5000));
+                continue;
+            }
+            const extractResult = extractResults[0];
+            const state = extractResult.state;
+            if (state === 'done') {
+                return extractResult;
+            }
+            else if (state === 'failed') {
+                const errMsg = extractResult.err_msg || 'Unknown error';
+                throw new Error(`Parse failed, reason: ${errMsg}`);
+            }
+            // Still processing, wait and retry
+            await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+        catch (error) {
+            if (attempt === MAX_RETRIES - 1) {
+                throw error;
+            }
+            console.warn(`Poll attempt ${attempt + 1} failed:`, error);
+            await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+    }
+    throw new Error('Polling timeout reached without getting completed result');
+}
+/**
+ * Process zip file entry
+ */
+async function processZipFile(zipEntry, fileName, content, workspacePath, baseUrl) {
+    try {
+        const fileContent = await zipEntry.async('nodebuffer');
+        if (fileName.startsWith('images/') && SUPPORTED_IMAGE_EXTENSIONS.some(ext => fileName.endsWith(ext))) {
+            const baseName = path.basename(fileName);
+            const filePath = path.join(workspacePath, baseName);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, fileContent);
+            const fileUrl = new URL(encodeURIComponent(baseName), baseUrl).href;
+            content.images.push({
+                mimeType: 'image/jpeg',
+                fileName: baseName,
+                filePath,
+                fileUrl,
+                extension: 'jpeg',
+            });
+        }
+        else if (fileName.endsWith('.md')) {
+            content.mdContent = fileContent.toString('utf-8');
+        }
+        else if (fileName.endsWith('.json') && fileName !== 'layout.json') {
+            try {
+                const jsonContent = JSON.parse(fileContent.toString('utf-8'));
+                content.contentList.push(jsonContent);
+            }
+            catch (error) {
+                console.error(`Failed to parse JSON file ${fileName}:`, error);
+            }
+        }
+        else if (fileName.endsWith('.html')) {
+            content.htmlContent = fileContent.toString('utf-8');
+        }
+        else if (fileName.endsWith('.docx')) {
+            content.docxContent = fileContent;
+        }
+        else if (fileName.endsWith('.tex')) {
+            content.latexContent = fileContent.toString('utf-8');
+        }
+    }
+    catch (error) {
+        console.error(`Failed to process file ${fileName}:`, error);
+    }
+}
+/**
+ * Download and extract zip file from URL
+ */
+async function downloadAndExtractZip(url, workspacePath, baseUrl) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download zip file: ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const zipBuffer = Buffer.from(arrayBuffer);
+    const zip = await JSZip.loadAsync(zipBuffer);
+    const content = {
+        mdContent: '',
+        contentList: [],
+        images: [],
+    };
+    // Process all files in zip
+    const promises = [];
+    zip.forEach((relativePath, zipEntry) => {
+        if (!zipEntry.dir) {
+            promises.push(processZipFile(zipEntry, relativePath, content, workspacePath, baseUrl));
+        }
+    });
+    await Promise.all(promises);
+    // Replace image paths in markdown
+    content.mdContent = replaceMdImgPath(content.mdContent, content.images);
+    return content;
+}
+/**
+ * Parse file using MinerU API
+ */
+async function parseFile(credentials, file, fileContent, fileName, toolParameters, workspacePath, baseUrl) {
+    const headers = getHeaders(credentials);
+    // Create parsing task
+    const data = {
+        enable_formula: toolParameters.enable_formula ?? true,
+        enable_table: toolParameters.enable_table ?? true,
+        language: toolParameters.language || 'auto',
+        model_version: toolParameters.model_version || 'pipeline',
+        extra_formats: typeof toolParameters.extra_formats === 'string'
+            ? JSON.parse(toolParameters.extra_formats || '[]')
+            : toolParameters.extra_formats || [],
+        files: [
+            {
+                name: fileName,
+                is_ocr: toolParameters.enable_ocr ?? false,
+            },
+        ],
+    };
+    const taskUrl = buildApiUrl(credentials.base_url, 'api/v4/file-urls/batch');
+    const response = await fetch(taskUrl, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(data),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Apply upload url failed. Status: ${response.status}, result: ${text}`);
+    }
+    const result = (await response.json());
+    if (result.code === 0) {
+        const batchId = result.data.batch_id;
+        const urls = result.data.file_urls;
+        // Upload file
+        const uploadResponse = await fetch(urls[0], {
+            method: 'PUT',
+            body: fileContent,
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(`Failed to upload file: ${uploadResponse.statusText}`);
+        }
+        // Poll for result
+        const extractResult = await pollGetParseResult(credentials, batchId);
+        const fullZipUrl = extractResult.full_zip_url;
+        if (!fullZipUrl) {
+            throw new Error('No zip URL found in parse result');
+        }
+        // Download and extract zip
+        const zipContent = await downloadAndExtractZip(fullZipUrl, workspacePath, baseUrl);
+        return {
+            markdown: zipContent.mdContent,
+            images: zipContent.images,
+            contentList: zipContent.contentList,
+            fullZipUrl,
+        };
+    }
+    else {
+        throw new Error(`Apply upload url failed, reason: ${result.msg || 'Unknown error'}`);
+    }
+}
+/**
+ * Validate credentials by checking API connection
+ */
+async function validateCredentials(credentials) {
+    const url = buildApiUrl(credentials.base_url, 'api/v4/file-urls/batch');
+    const headers = getHeaders(credentials);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({}),
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+        throw new Error('Please check your base_url and token');
+    }
+}
+/**
+ * Build parse file tool
+ * @param credentials - MinerU API credentials (base_url and token)
+ */
+export function buildParseFileTool(credentials) {
+    return tool(async (input) => {
+        try {
+            const { file, fileUrl, filePath, content, enable_formula, enable_table, language, enable_ocr, extra_formats, model_version, } = input;
+            // Validate credentials are available
+            if (!credentials?.base_url) {
+                throw new Error('base_url is not configured. Please configure MinerU toolset with base_url and token.');
+            }
+            if (!credentials?.token) {
+                throw new Error('token is not configured. Please configure MinerU toolset with base_url and token.');
+            }
+            // Validate credentials
+            try {
+                await validateCredentials(credentials);
+            }
+            catch (error) {
+                const errorMsg = error?.message || String(error);
+                if (errorMsg.includes('fetch failed') || errorMsg.includes('ECONNREFUSED')) {
+                    throw new Error(`Cannot connect to MinerU service at ${credentials.base_url}. ` +
+                        `Please ensure MinerU service is running and accessible. ` +
+                        `Error: ${errorMsg}`);
+                }
+                throw error;
+            }
+            // Get file content
+            let fileContent;
+            let fileName;
+            if (fileUrl) {
+                // Download file from URL (preferred input method)
+                const response = await fetch(fileUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to download file: ${response.statusText}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                fileContent = Buffer.from(arrayBuffer);
+                // Extract file name from URL pathname, fallback to file object if provided
+                fileName = file?.fileName || file?.filename || path.basename(new URL(fileUrl).pathname) || 'file';
+            }
+            else if (filePath) {
+                fileContent = await fs.readFile(filePath);
+                fileName = file?.fileName || path.basename(filePath) || 'file';
+            }
+            else if (file?.content) {
+                fileContent = Buffer.isBuffer(file.content)
+                    ? file.content
+                    : Buffer.from(file.content);
+                fileName = file.fileName || file.filename || 'file';
+            }
+            else if (content) {
+                fileContent = Buffer.isBuffer(content)
+                    ? content
+                    : typeof content === 'string'
+                        ? Buffer.from(content, 'base64')
+                        : Buffer.from(content);
+                fileName = file?.fileName || 'file';
+            }
+            else {
+                throw new Error('File is required');
+            }
+            // Validate file type
+            validateFileType(fileName);
+            // Get workspace paths
+            let workspacePath = '/tmp/xpert';
+            let baseUrl = 'http://localhost:3000';
+            try {
+                const currentState = getCurrentTaskInput();
+                workspacePath = currentState?.['sys']?.['volume'] ?? workspacePath;
+                baseUrl = currentState?.['sys']?.['workspace_url'] ?? baseUrl;
+            }
+            catch (error) {
+                // If getCurrentTaskInput fails (e.g., in test environment), use defaults
+                console.warn('getCurrentTaskInput failed, using default paths:', error);
+            }
+            // Parse file using MinerU API
+            const result = await parseFile(credentials, file, fileContent, fileName, { enable_formula, enable_table, language, enable_ocr, extra_formats, model_version }, workspacePath, baseUrl);
+            // Build response with artifacts
+            const artifacts = {
+                files: [
+                    // Markdown file
+                    {
+                        mimeType: 'text/markdown',
+                        fileName: `${path.parse(fileName).name}.md`,
+                        filePath: path.join(workspacePath, `${path.parse(fileName).name}.md`),
+                        fileUrl: new URL(encodeURIComponent(`${path.parse(fileName).name}.md`), baseUrl).href,
+                        extension: 'md',
+                    },
+                    // Images
+                    ...result.images,
+                ],
+            };
+            // Add JSON content list if available
+            if (result.contentList.length > 0) {
+                const jsonFileName = `${path.parse(fileName).name}.json`;
+                const jsonPath = path.join(workspacePath, jsonFileName);
+                await fs.writeFile(jsonPath, JSON.stringify(result.contentList, null, 2));
+                artifacts.files.push({
+                    mimeType: 'application/json',
+                    fileName: jsonFileName,
+                    filePath: jsonPath,
+                    fileUrl: new URL(encodeURIComponent(jsonFileName), baseUrl).href,
+                    extension: 'json',
+                });
+            }
+            // Save markdown to file
+            const mdFileName = `${path.parse(fileName).name}.md`;
+            const mdPath = path.join(workspacePath, mdFileName);
+            await fs.writeFile(mdPath, result.markdown, 'utf-8');
+            return [
+                result.markdown,
+                artifacts,
+            ];
+        }
+        catch (error) {
+            const errorMsg = getErrorMessage(error);
+            // Provide more helpful error messages for common issues
+            if (errorMsg.includes('fetch failed') || errorMsg.includes('ECONNREFUSED')) {
+                throw new Error(`Cannot connect to MinerU service. ` +
+                    `Please ensure MinerU service is running and accessible at the configured base_url. ` +
+                    `Original error: ${errorMsg}`);
+            }
+            throw new Error(`Error parsing file: ${errorMsg}`);
+        }
+    }, {
+        name: 'parse-file',
+        description: 'A tool for parsing text, tables, and images, supporting multiple formats such as pdf, pptx, docx, etc. supporting multiple languages such as English, Chinese, etc.',
+        schema: z.object({
+            fileUrl: z.string().optional().nullable().describe('URL of the file to parse (preferred input method)'),
+            filePath: z.string().optional().nullable().describe('Local path of the file to parse'),
+            file: z.any().optional().nullable().describe('The file object to be parsed (support pdf, ppt, pptx, doc, docx, png, jpg, jpeg)'),
+            content: z.union([z.string(), z.instanceof(Buffer), z.instanceof(Uint8Array)]).optional().nullable().describe('File content'),
+            enable_formula: z.boolean().optional().nullable().describe('Whether to enable formula recognition'),
+            enable_table: z.boolean().optional().nullable().describe('Whether to enable table recognition'),
+            language: z.string().optional().nullable().describe('Specify document language, default is auto'),
+            enable_ocr: z.boolean().optional().nullable().describe('Whether to enable OCR recognition'),
+            extra_formats: z.string().optional().nullable().describe('Example: ["docx","html"], markdown, json are the default export formats'),
+            model_version: z.enum(['pipeline', 'vlm']).optional().nullable().describe('MinerU model version; options: pipeline or vlm, default is pipeline'),
+        }),
+        responseFormat: 'content_and_artifact',
+    });
+}

package/dist/lib/plugin.d.ts

@@ -0,0 +1,16 @@
+import { IOnPluginBootstrap, IOnPluginDestroy } from '@xpert-ai/plugin-sdk';
+/**
+ * MinerU plugin class that implements plugin lifecycle hooks
+ */
+export declare class MinerUPlugin implements IOnPluginBootstrap, IOnPluginDestroy {
+    private logEnabled;
+    /**
+     * Called when the plugin is being initialized.
+     */
+    onPluginBootstrap(): void | Promise<void>;
+    /**
+     * Called when the plugin is being destroyed.
+     */
+    onPluginDestroy(): void | Promise<void>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/lib/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/lib/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI9F;;GAEG;AACH,qBAaa,YAAa,YAAW,kBAAkB,EAAE,gBAAgB;IAEvE,OAAO,CAAC,UAAU,CAAO;IAEzB;;OAEG;IACH,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC;;OAEG;IACH,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKxC"}

package/dist/lib/plugin.js

@@ -0,0 +1,46 @@
+var MinerUPlugin_1;
+import { __decorate } from "tslib";
+import chalk from 'chalk';
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import { ConfigModule } from '@nestjs/config';
+import { MinerUStrategy } from './strategy.js';
+/**
+ * MinerU plugin class that implements plugin lifecycle hooks
+ */
+let MinerUPlugin = MinerUPlugin_1 = class MinerUPlugin {
+    constructor() {
+        // We disable by default additional logging for each event to avoid cluttering the logs
+        this.logEnabled = true;
+    }
+    /**
+     * Called when the plugin is being initialized.
+     */
+    onPluginBootstrap() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MinerUPlugin_1.name} is being bootstrapped...`));
+        }
+    }
+    /**
+     * Called when the plugin is being destroyed.
+     */
+    onPluginDestroy() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MinerUPlugin_1.name} is being destroyed...`));
+        }
+    }
+};
+MinerUPlugin = MinerUPlugin_1 = __decorate([
+    XpertServerPlugin({
+        /**
+         * An array of modules that will be imported and registered with the plugin.
+         */
+        imports: [ConfigModule],
+        /**
+         * An array of Entity classes. The plugin (or ORM) will
+         * register these entities for use within the application.
+         */
+        entities: [],
+        providers: [MinerUStrategy],
+    })
+], MinerUPlugin);
+export { MinerUPlugin };

package/dist/lib/strategy.d.ts

@@ -0,0 +1,42 @@
+import { BuiltinToolset, IToolsetStrategy } from '@xpert-ai/plugin-sdk';
+/**
+ * MinerU toolset strategy implementation
+ */
+export declare class MinerUStrategy implements IToolsetStrategy<any> {
+    meta: {
+        author: string;
+        tags: string[];
+        name: string;
+        label: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        description: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            svg: string;
+            color: string;
+        };
+        configSchema: {
+            type: string;
+            properties: {};
+            required: any[];
+        };
+    };
+    /**
+     * Validate configuration
+     */
+    validateConfig(config: any): Promise<void>;
+    /**
+     * Create toolset instance
+     */
+    create(config: any): Promise<BuiltinToolset>;
+    /**
+     * Create tools for this toolset
+     * Note: When using BuiltinToolset, this method may not be used, initTools is used instead
+     */
+    createTools(): any[];
+}
+//# sourceMappingURL=strategy.d.ts.map

package/dist/lib/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../src/lib/strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAmB,MAAM,sBAAsB,CAAA;AAKxF;;GAEG;AACH,qBAEa,cAAe,YAAW,gBAAgB,CAAC,GAAG,CAAC;IAC1D,IAAI;;;;;;;;;;;;;;;;;;;;;MAuBH;IAED;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1C;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC;IAKlD;;;OAGG;IACH,WAAW;CAKZ"}

package/dist/lib/strategy.js

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@nestjs/common';
+import { ToolsetStrategy } from '@xpert-ai/plugin-sdk';
+import { MinerU, icon } from './types.js';
+import { MinerUToolset } from './toolset.js';
+/**
+ * MinerU toolset strategy implementation
+ */
+let MinerUStrategy = class MinerUStrategy {
+    constructor() {
+        this.meta = {
+            author: 'Xpert AI',
+            tags: ['mineru', 'pdf', 'parser', 'document', 'tool'],
+            name: MinerU,
+            label: {
+                en_US: 'MinerU',
+                zh_Hans: 'MinerU',
+            },
+            description: {
+                en_US: 'MinerU is a tool that converts FILES into machine-readable formats (e.g., markdown, JSON), allowing for easy extraction into any format. MinerU was born during the pre-training process of InternLM. We focus on solving symbol conversion issues in scientific literature and hope to contribute to technological development in the era of large models.',
+                zh_Hans: 'MinerU是一款可以在本地部署的将FILES转化为机器可读格式的工具（如markdown、json），可以很方便地抽取为任意格式。MinerU诞生于书生-浦语的预训练过程中，我们将会集中精力解决科技文献中的符号转化问题，希望在大模型时代为科技发展做出贡献。',
+            },
+            icon: {
+                svg: icon,
+                color: '#4a90e2',
+            },
+            configSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        };
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        // No validation needed, credentials are hardcoded
+        return Promise.resolve();
+    }
+    /**
+     * Create toolset instance
+     */
+    async create(config) {
+        // Credentials are hardcoded in toolset, config is not used
+        return new MinerUToolset(config || {});
+    }
+    /**
+     * Create tools for this toolset
+     * Note: When using BuiltinToolset, this method may not be used, initTools is used instead
+     */
+    createTools() {
+        // This should not be called when using BuiltinToolset, but required by interface
+        // Return empty array as fallback - actual tools are created in toolset.initTools()
+        return [];
+    }
+};
+MinerUStrategy = __decorate([
+    Injectable(),
+    ToolsetStrategy(MinerU)
+], MinerUStrategy);
+export { MinerUStrategy };

package/dist/lib/toolset.d.ts

@@ -0,0 +1,16 @@
+import { StructuredToolInterface, ToolSchemaBase } from '@langchain/core/tools';
+import { BuiltinToolset } from '@xpert-ai/plugin-sdk';
+/**
+ * MinerU toolset class that manages all MinerU tools
+ */
+export declare class MinerUToolset extends BuiltinToolset<StructuredToolInterface, any> {
+    /**
+     * Validate credentials for MinerU toolset
+     */
+    _validateCredentials(credentials: any): Promise<void>;
+    /**
+     * Initialize tools for MinerU toolset
+     */
+    initTools(): Promise<StructuredToolInterface<ToolSchemaBase, any, any>[]>;
+}
+//# sourceMappingURL=toolset.d.ts.map

package/dist/lib/toolset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolset.d.ts","sourceRoot":"","sources":["../../src/lib/toolset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAIrD;;GAEG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,uBAAuB,EAAE,GAAG,CAAC;IAC7E;;OAEG;IACY,oBAAoB,CAAC,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpE;;OAEG;IACY,SAAS,IAAI,OAAO,CAAC,uBAAuB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;CAKzF"}

package/dist/lib/toolset.js

@@ -0,0 +1,22 @@
+import { BuiltinToolset } from '@xpert-ai/plugin-sdk';
+import { buildParseFileTool } from './parse.tool.js';
+import { DEFAULT_CREDENTIALS } from './types.js';
+/**
+ * MinerU toolset class that manages all MinerU tools
+ */
+export class MinerUToolset extends BuiltinToolset {
+    /**
+     * Validate credentials for MinerU toolset
+     */
+    async _validateCredentials(credentials) {
+        // Credentials are hardcoded, no validation needed
+    }
+    /**
+     * Initialize tools for MinerU toolset
+     */
+    async initTools() {
+        // Use hardcoded credentials
+        this.tools = [buildParseFileTool(DEFAULT_CREDENTIALS)];
+        return this.tools;
+    }
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,28 @@
+export declare const MinerU = "mineru";
+export declare const icon: string;
+export declare const SUPPORTED_EXTENSIONS: string[];
+export declare const SUPPORTED_IMAGE_EXTENSIONS: string[];
+export declare const MAX_RETRIES = 50;
+export declare const MINERU_BASE_URL = "https://mineru.net";
+export declare const MINERU_TOKEN = "eyJ0eXBlIjoiSldUIiwiYWxnIjoiSFM1MTIifQ.eyJqdGkiOiI1MjAwMDg2NCIsInJvbCI6IlJPTEVfUkVHSVNURVIiLCJpc3MiOiJPcGVuWExhYiIsImlhdCI6MTc2NjA0NzI0OCwiY2xpZW50SWQiOiJsa3pkeDU3bnZ5MjJqa3BxOXgydyIsInBob25lIjoiIiwib3BlbklkIjpudWxsLCJ1dWlkIjoiYjc4MzIxNDItMjA0Yi00MDk1LTk2MjMtNzdhMzhlNTU2NzcyIiwiZW1haWwiOiIiLCJleHAiOjE3NjcyNTY4NDh9.xy9gFita6it7FBWNRrx-EUzpD9Mr5yhJBZ8m9hHOzrO3RfM9E1IE8AlW8lZSV4cxexuNPKisvCpW6c-RfjbHZw";
+export declare const DEFAULT_CREDENTIALS: Credentials;
+export interface Credentials {
+    base_url: string;
+    token: string;
+}
+export interface ZipContent {
+    mdContent: string;
+    contentList: Array<Record<string, any>>;
+    images: Array<any>;
+    htmlContent?: string;
+    docxContent?: Buffer;
+    latexContent?: string;
+}
+export interface TFileInfo {
+    mimeType: string;
+    fileName: string;
+    fileUrl?: string;
+    filePath: string;
+    extension?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,WAAW,CAAA;AAK9B,eAAO,MAAM,IAAI,QAAkE,CAAA;AAGnF,eAAO,MAAM,oBAAoB,UAAsE,CAAA;AAGvG,eAAO,MAAM,0BAA0B,UAA4B,CAAA;AAGnE,eAAO,MAAM,WAAW,KAAK,CAAA;AAG7B,eAAO,MAAM,eAAe,uBAAuB,CAAA;AACnD,eAAO,MAAM,YAAY,uZAAuZ,CAAA;AAGhb,eAAO,MAAM,mBAAmB,EAAE,WAGjC,CAAA;AAGD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd;AAGD,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;IACvC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAGD,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB"}

package/dist/lib/types.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// MinerU plugin identifier
+export const MinerU = 'mineru';
+// SVG icon for mineru plugin (loaded from _assets/icon.svg)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const icon = readFileSync(join(__dirname, '../../_assets/icon.svg'), 'utf8');
+// Supported file extensions
+export const SUPPORTED_EXTENSIONS = ['.pdf', '.doc', '.docx', '.ppt', '.pptx', '.png', '.jpg', '.jpeg'];
+// Supported image extensions
+export const SUPPORTED_IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg'];
+// Maximum retries for polling
+export const MAX_RETRIES = 50;
+// Hardcoded MinerU API credentials
+export const MINERU_BASE_URL = 'https://mineru.net';
+export const MINERU_TOKEN = 'eyJ0eXBlIjoiSldUIiwiYWxnIjoiSFM1MTIifQ.eyJqdGkiOiI1MjAwMDg2NCIsInJvbCI6IlJPTEVfUkVHSVNURVIiLCJpc3MiOiJPcGVuWExhYiIsImlhdCI6MTc2NjA0NzI0OCwiY2xpZW50SWQiOiJsa3pkeDU3bnZ5MjJqa3BxOXgydyIsInBob25lIjoiIiwib3BlbklkIjpudWxsLCJ1dWlkIjoiYjc4MzIxNDItMjA0Yi00MDk1LTk2MjMtNzdhMzhlNTU2NzcyIiwiZW1haWwiOiIiLCJleHAiOjE3NjcyNTY4NDh9.xy9gFita6it7FBWNRrx-EUzpD9Mr5yhJBZ8m9hHOzrO3RfM9E1IE8AlW8lZSV4cxexuNPKisvCpW6c-RfjbHZw';
+// Default credentials
+export const DEFAULT_CREDENTIALS = {
+    base_url: MINERU_BASE_URL,
+    token: MINERU_TOKEN,
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@chenchaolong/plugin-mineru-chen",
+  "version": "1.0.0",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xpert-ai/xpert-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xpert-ai/xpert-plugins/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@xpert-plugins-starter/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "jszip": "^3.10.1",
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": "0.3.72",
+    "@langchain/langgraph": "0.4.7",
+    "@nestjs/common": "^11.1.6",
+    "@nestjs/config": "^4.0.2",
+    "@xpert-ai/plugin-sdk": "^3.6.2",
+    "chalk": "4.1.2",
+    "zod": "3.25.67"
+  }
+}