@chenchaolong/plugin-mineru 0.0.9

package/dist/lib/pdf-to-markdown.tool.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { ConfigService } from '@nestjs/config';
+import { MinerUResultParserService } from './result-parser.service.js';
+export declare function buildPdfToMarkdownTool(configService: ConfigService, resultParser: MinerUResultParserService): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    file: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>]>>;
+        filePath: z.ZodOptional<z.ZodString>;
+        fileUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    }, {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    }>;
+    isOcr: z.ZodOptional<z.ZodBoolean>;
+    enableFormula: z.ZodOptional<z.ZodBoolean>;
+    enableTable: z.ZodOptional<z.ZodBoolean>;
+    language: z.ZodOptional<z.ZodEnum<["en", "ch"]>>;
+    modelVersion: z.ZodOptional<z.ZodEnum<["pipeline", "vlm"]>>;
+}, "strip", z.ZodTypeAny, {
+    file?: {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    };
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    language?: "en" | "ch";
+    modelVersion?: "vlm" | "pipeline";
+}, {
+    file?: {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    };
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    language?: "en" | "ch";
+    modelVersion?: "vlm" | "pipeline";
+}>, {
+    file?: {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    };
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    language?: "en" | "ch";
+    modelVersion?: "vlm" | "pipeline";
+}, {
+    file?: {
+        name?: string;
+        filename?: string;
+        content?: string | Uint8Array<ArrayBuffer> | Buffer<ArrayBufferLike>;
+        filePath?: string;
+        fileUrl?: string;
+    };
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    language?: "en" | "ch";
+    modelVersion?: "vlm" | "pipeline";
+}, (string | {
+    files: {
+        mimeType: string;
+        fileName: string;
+        filePath: string;
+        fileUrl: string;
+        extension: string;
+    }[];
+})[]>;
+//# sourceMappingURL=pdf-to-markdown.tool.d.ts.map

package/dist/lib/pdf-to-markdown.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-to-markdown.tool.d.ts","sourceRoot":"","sources":["../../src/lib/pdf-to-markdown.tool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAIvE,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqKxC"}

package/dist/lib/pdf-to-markdown.tool.js

@@ -0,0 +1,146 @@
+import { tool } from '@langchain/core/tools';
+import { getCurrentTaskInput } from '@langchain/langgraph';
+import { getErrorMessage } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+import { MinerUClient } from './mineru.client.js';
+export function buildPdfToMarkdownTool(configService, resultParser) {
+    return tool(async (input) => {
+        try {
+            const { file, isOcr, enableFormula, enableTable, language, modelVersion } = input;
+            if (!file) {
+                throw new Error('No file provided');
+            }
+            const currentState = getCurrentTaskInput();
+            const workspacePath = currentState?.[`sys`]?.['volume'] ?? '/tmp/xpert';
+            const baseUrl = currentState?.[`sys`]?.['workspace_url'] ?? 'http://localhost:3000';
+            // Get permissions from current state
+            const permissions = currentState?.[`sys`]?.['permissions'];
+            if (!permissions?.fileSystem) {
+                throw new Error('File system permission is required for MinerU tool');
+            }
+            // Get file content
+            let fileContent;
+            let fileName;
+            let filePath;
+            let fileUrl;
+            if (file.content) {
+                if (typeof file.content === 'string') {
+                    // Base64 string
+                    fileContent = Buffer.from(file.content, 'base64');
+                }
+                else if (Buffer.isBuffer(file.content)) {
+                    fileContent = file.content;
+                }
+                else if (file.content instanceof Uint8Array) {
+                    fileContent = Buffer.from(file.content);
+                }
+                else {
+                    throw new Error('Invalid file content format');
+                }
+                fileName = file.name || file.filename || 'document.pdf';
+            }
+            else if (file.filePath) {
+                filePath = file.filePath;
+                fileContent = await permissions.fileSystem.readFile(filePath);
+                fileName = file.name || file.filename || filePath.split('/').pop() || 'document.pdf';
+            }
+            else if (file.fileUrl) {
+                fileUrl = file.fileUrl;
+                const response = await fetch(fileUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to download file from URL: ${response.statusText}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                fileContent = Buffer.from(arrayBuffer);
+                fileName = file.name || file.filename || fileUrl.split('/').pop() || 'document.pdf';
+            }
+            else {
+                throw new Error('File must provide content, filePath, or fileUrl');
+            }
+            // Save file to workspace if not already there
+            if (!filePath) {
+                const relativePath = `mineru-input/${fileName}`;
+                filePath = relativePath;
+                fileUrl = await permissions.fileSystem.writeFile(relativePath, fileContent);
+            }
+            // Create MinerU client
+            const mineruClient = new MinerUClient(configService, {
+                fileSystem: permissions.fileSystem,
+                integration: permissions.integration,
+            });
+            // Create task
+            const { taskId } = await mineruClient.createTask({
+                url: fileUrl || file.fileUrl,
+                filePath: filePath,
+                fileName: fileName,
+                isOcr: isOcr ?? true,
+                enableFormula: enableFormula ?? true,
+                enableTable: enableTable ?? true,
+                language: language || 'ch',
+                modelVersion: modelVersion || 'pipeline',
+            });
+            // Get result
+            let result;
+            if (mineruClient.serverType === 'self-hosted') {
+                result = mineruClient.getSelfHostedTask(taskId);
+                if (!result) {
+                    throw new Error('Failed to get MinerU task result');
+                }
+            }
+            else {
+                result = await mineruClient.waitForTask(taskId, 5 * 60 * 1000, 5000);
+            }
+            // Parse result
+            const parsedResult = mineruClient.serverType === 'self-hosted'
+                ? await resultParser.parseLocalTask(result, taskId, { folder: 'mineru-output', name: fileName }, permissions.fileSystem)
+                : await resultParser.parseFromUrl(result.full_zip_url, taskId, { folder: 'mineru-output', name: fileName }, permissions.fileSystem);
+            // Get markdown content
+            const markdownContent = parsedResult.chunks[0]?.pageContent || '';
+            const outputFileName = fileName.replace(/\.pdf$/i, '.md');
+            const outputPath = `mineru-output/${outputFileName}`;
+            const outputUrl = await permissions.fileSystem.writeFile(outputPath, Buffer.from(markdownContent, 'utf-8'));
+            return [
+                `Successfully converted PDF to Markdown: ${outputFileName}`,
+                {
+                    files: [
+                        {
+                            mimeType: 'text/markdown',
+                            fileName: outputPath,
+                            filePath: permissions.fileSystem.fullPath(outputPath),
+                            fileUrl: outputUrl,
+                            extension: 'md',
+                        },
+                        ...(parsedResult.metadata.assets || []).map((asset) => ({
+                            mimeType: asset.type === 'image' ? 'image/png' : 'application/json',
+                            fileName: asset.filePath,
+                            filePath: permissions.fileSystem.fullPath(asset.filePath),
+                            fileUrl: asset.url,
+                            extension: asset.type === 'image' ? 'png' : 'json',
+                        })),
+                    ],
+                },
+            ];
+        }
+        catch (error) {
+            throw new Error(`Error converting PDF to Markdown: ${getErrorMessage(error)}`);
+        }
+    }, {
+        name: 'pdf_to_markdown',
+        description: `Convert PDF file to Markdown format using MinerU. Supports OCR, formula recognition, and table extraction.`,
+        schema: z.object({
+            file: z.object({
+                name: z.string().optional(),
+                filename: z.string().optional(),
+                content: z.union([z.string(), z.instanceof(Buffer), z.instanceof(Uint8Array)]).optional(),
+                filePath: z.string().optional(),
+                fileUrl: z.string().optional(),
+            }),
+            isOcr: z.boolean().optional().describe('Enable OCR for image-based PDFs'),
+            enableFormula: z.boolean().optional().describe('Enable recognition of mathematical formulas'),
+            enableTable: z.boolean().optional().describe('Enable recognition of tables'),
+            language: z.enum(['en', 'ch']).optional().describe('Document language (en for English, ch for Chinese)'),
+            modelVersion: z.enum(['pipeline', 'vlm']).optional().describe('MinerU model version'),
+        }),
+        responseFormat: 'content_and_artifact',
+    });
+}

package/dist/lib/result-parser.service.d.ts

@@ -0,0 +1,18 @@
+import { Document } from '@langchain/core/documents';
+import { IKnowledgeDocument } from '@metad/contracts';
+import { ChunkMetadata, XpFileSystem } from '@xpert-ai/plugin-sdk';
+import { MinerUDocumentMetadata, MineruSelfHostedTaskResult } from './types.js';
+export declare class MinerUResultParserService {
+    private readonly logger;
+    parseFromUrl(fullZipUrl: string, taskId: string, document: Partial<IKnowledgeDocument>, fileSystem: XpFileSystem): Promise<{
+        id?: string;
+        chunks: Document<ChunkMetadata>[];
+        metadata: MinerUDocumentMetadata;
+    }>;
+    parseLocalTask(result: MineruSelfHostedTaskResult, taskId: string, document: Partial<IKnowledgeDocument>, fileSystem: XpFileSystem): Promise<{
+        id?: string;
+        chunks: Document<ChunkMetadata>[];
+        metadata: MinerUDocumentMetadata;
+    }>;
+}
+//# sourceMappingURL=result-parser.service.d.ts.map

package/dist/lib/result-parser.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-parser.service.d.ts","sourceRoot":"","sources":["../../src/lib/result-parser.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EACL,aAAa,EAEb,YAAY,EACb,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EAEL,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,qBACa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8C;IAE/D,YAAY,CAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,UAAU,EAAE,YAAY,GACvB,OAAO,CAAC;QACT,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAClC,QAAQ,EAAE,sBAAsB,CAAC;KAClC,CAAC;IAqFI,cAAc,CAClB,MAAM,EAAE,0BAA0B,EAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,UAAU,EAAE,YAAY,GACvB,OAAO,CAAC;QACT,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAClC,QAAQ,EAAE,sBAAsB,CAAC;KAClC,CAAC;CAkDH"}

package/dist/lib/result-parser.service.js

@@ -0,0 +1,142 @@
+var MinerUResultParserService_1;
+import { __decorate } from "tslib";
+import { Document } from '@langchain/core/documents';
+import { Injectable, Logger } from '@nestjs/common';
+import axios from 'axios';
+import { join } from 'path';
+import unzipper from 'unzipper';
+import { v4 as uuidv4 } from 'uuid';
+import { MinerU, } from './types.js';
+let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResultParserService {
+    constructor() {
+        this.logger = new Logger(MinerUResultParserService_1.name);
+    }
+    async parseFromUrl(fullZipUrl, taskId, document, fileSystem) {
+        this.logger.debug(`Downloading MinerU result from: ${fullZipUrl}`);
+        // 1. Download the zip file to memory
+        const response = await axios.get(fullZipUrl, {
+            responseType: 'arraybuffer',
+        });
+        const zipBuffer = Buffer.from(response.data);
+        const metadata = {
+            parser: MinerU,
+            taskId,
+        };
+        // 2. Unzip the file
+        const zipEntries = [];
+        const assets = [];
+        const directory = await unzipper.Open.buffer(zipBuffer);
+        const pathMap = new Map();
+        let fullMd = '';
+        let layoutJson = null;
+        for (const entry of directory.files) {
+            if (!entry.type || entry.type !== 'File')
+                continue;
+            const data = await entry.buffer();
+            zipEntries.push({ entryName: entry.path, data });
+            const fileName = entry.path;
+            const filePath = join(document.folder || '', entry.path);
+            const url = await fileSystem.writeFile(filePath, data);
+            pathMap.set(fileName, url);
+            // Write images to local file system
+            if (fileName.startsWith('images/')) {
+                assets.push({
+                    type: 'image',
+                    url: url,
+                    filePath: filePath,
+                });
+            }
+            else if (fileName.endsWith('layout.json')) {
+                layoutJson = JSON.parse(data.toString('utf-8'));
+                metadata.mineruBackend = layoutJson?._backend;
+                metadata.mineruVersion = layoutJson?._version_name;
+                assets.push({
+                    type: 'file',
+                    url,
+                    filePath: filePath,
+                });
+            }
+            else if (fileName.endsWith('content_list.json')) {
+                assets.push({
+                    type: 'file',
+                    url,
+                    filePath: filePath,
+                });
+            }
+            else if (fileName.endsWith('full.md')) {
+                fullMd = data.toString('utf-8');
+                assets.push({
+                    type: 'file',
+                    url,
+                    filePath: filePath,
+                });
+            }
+            else if (fileName.endsWith('origin.pdf')) {
+                metadata.originPdfUrl = fileName;
+            }
+        }
+        metadata.assets = assets;
+        // 3. Replace image relative path in full.md with file url
+        fullMd = fullMd.replace(/!\[(.*)\]\((images\/.+?)\)/g, (match, p1, p2) => {
+            const localPath = pathMap.get(p2);
+            return localPath ? `![${p1}](${localPath})` : match;
+        });
+        const chunks = [
+            new Document({
+                pageContent: fullMd,
+                metadata: { parser: MinerU, taskId, chunkId: uuidv4() },
+            }),
+        ];
+        return {
+            chunks,
+            metadata,
+        };
+    }
+    async parseLocalTask(result, taskId, document, fileSystem) {
+        const metadata = {
+            parser: MinerU,
+            taskId,
+        };
+        const assets = [];
+        const pathMap = new Map();
+        for (const image of result.images) {
+            const filePath = join(document.folder || '', 'images', image.name);
+            const url = await fileSystem.writeFile(filePath, Buffer.from(image.dataUrl.split(',')[1], 'base64'));
+            pathMap.set(`images/${image.name}`, url);
+            assets.push({
+                type: 'image',
+                url: url,
+                filePath: filePath,
+            });
+        }
+        if (result.sourceUrl) {
+            assets.push({
+                type: 'file',
+                url: result.sourceUrl,
+                filePath: join(document.folder || '', result.fileName || 'source.pdf'),
+            });
+            metadata.originPdfUrl = result.sourceUrl;
+        }
+        metadata.assets = assets;
+        let fullMd = result.mdContent;
+        // 3. Replace image relative path in full.md with file url
+        fullMd = fullMd.replace(/!\[(.*)\]\((images\/.+?)\)/g, (match, p1, p2) => {
+            const localPath = pathMap.get(p2);
+            return localPath ? `![${p1}](${localPath})` : match;
+        });
+        const chunks = [
+            new Document({
+                pageContent: fullMd,
+                metadata: { parser: MinerU, taskId, chunkId: uuidv4() },
+            }),
+        ];
+        return {
+            chunks,
+            metadata,
+        };
+    }
+};
+MinerUResultParserService = MinerUResultParserService_1 = __decorate([
+    Injectable()
+], MinerUResultParserService);
+export { MinerUResultParserService };

package/dist/lib/transformer-mineru.strategy.d.ts

@@ -0,0 +1,95 @@
+import { IconType, IKnowledgeDocument } from '@metad/contracts';
+import { ChunkMetadata, FileSystemPermission, IDocumentTransformerStrategy, IntegrationPermission } from '@xpert-ai/plugin-sdk';
+import { TMinerUTransformerConfig } from './types.js';
+export declare class MinerUTransformerStrategy implements IDocumentTransformerStrategy<TMinerUTransformerConfig> {
+    private readonly resultParser;
+    private readonly configService;
+    readonly permissions: (IntegrationPermission | FileSystemPermission)[];
+    readonly meta: {
+        name: string;
+        label: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        description: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            type: IconType;
+            value: string;
+            color: string;
+        };
+        helpUrl: string;
+        configSchema: {
+            type: string;
+            properties: {
+                isOcr: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: boolean;
+                };
+                enableFormula: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: boolean;
+                };
+                enableTable: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: boolean;
+                };
+                language: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: string;
+                };
+                modelVersion: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                };
+            };
+            required: any[];
+        };
+    };
+    validateConfig(config: any): Promise<void>;
+    transformDocuments(documents: Partial<IKnowledgeDocument>[], config: TMinerUTransformerConfig): Promise<Partial<IKnowledgeDocument<ChunkMetadata>>[]>;
+}
+//# sourceMappingURL=transformer-mineru.strategy.d.ts.map

package/dist/lib/transformer-mineru.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer-mineru.strategy.d.ts","sourceRoot":"","sources":["../../src/lib/transformer-mineru.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAG/D,OAAO,EACL,aAAa,EAEb,oBAAoB,EACpB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,sBAAsB,CAAA;AAI7B,OAAO,EAAgB,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEnE,qBAEa,yBAA0B,YAAW,4BAA4B,CAAC,wBAAwB,CAAC;IAEtG,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;IAGxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAE7C,QAAQ,CAAC,WAAW,mDAWnB;IAED,QAAQ,CAAC,IAAI;;;;;;;;;;;kBAWM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwE1B;IAED,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpC,kBAAkB,CACtB,SAAS,EAAE,OAAO,CAAC,kBAAkB,CAAC,EAAE,EACxC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;CAsDzD"}

package/dist/lib/transformer-mineru.strategy.js

@@ -0,0 +1,163 @@
+import { __decorate, __metadata } from "tslib";
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DocumentTransformerStrategy, } from '@xpert-ai/plugin-sdk';
+import { isNil, omitBy, pick } from 'lodash-es';
+import { MinerUClient } from './mineru.client.js';
+import { MinerUResultParserService } from './result-parser.service.js';
+import { icon, MinerU } from './types.js';
+let MinerUTransformerStrategy = class MinerUTransformerStrategy {
+    constructor() {
+        this.permissions = [
+            {
+                type: 'integration',
+                service: MinerU,
+                description: 'Access to MinerU system integrations'
+            },
+            {
+                type: 'filesystem',
+                operations: ['read', 'write', 'list'],
+                scope: []
+            }
+        ];
+        this.meta = {
+            name: MinerU,
+            label: {
+                en_US: 'MinerU',
+                zh_Hans: 'MinerU'
+            },
+            description: {
+                en_US: 'A high-quality tool for convert PDF to Markdown and JSON.',
+                zh_Hans: '一站式开源高质量数据提取工具，将PDF转换成Markdown和JSON格式。'
+            },
+            icon: {
+                type: 'svg',
+                value: icon,
+                color: '#14b8a6'
+            },
+            helpUrl: 'https://mineru.net/apiManage/docs',
+            configSchema: {
+                type: 'object',
+                properties: {
+                    isOcr: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Enable OCR',
+                            zh_Hans: '启用 OCR'
+                        },
+                        description: {
+                            en_US: 'Enable OCR for image-based PDFs.',
+                            zh_Hans: '对基于图像的 PDF 启用 OCR。'
+                        },
+                        default: true
+                    },
+                    enableFormula: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Enable Formula Recognition',
+                            zh_Hans: '启用公式识别'
+                        },
+                        description: {
+                            en_US: 'Enable recognition of mathematical formulas in documents.',
+                            zh_Hans: '启用对文档中数学公式的识别。'
+                        },
+                        default: true
+                    },
+                    enableTable: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Enable Table Recognition',
+                            zh_Hans: '启用表格识别'
+                        },
+                        description: {
+                            en_US: 'Enable recognition of tables in documents.',
+                            zh_Hans: '启用对文档中表格的识别。'
+                        },
+                        default: true
+                    },
+                    language: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Document Language',
+                            zh_Hans: '文档语言'
+                        },
+                        description: {
+                            en_US: 'The primary language of the document (e.g., "en" for English, "ch" for Chinese).',
+                            zh_Hans: '文档的主要语言（例如，英文为 "en"，中文为 "ch"）。'
+                        },
+                        default: 'ch'
+                    },
+                    modelVersion: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Model Version',
+                            zh_Hans: '模型版本'
+                        },
+                        description: {
+                            en_US: 'The model version to use for extraction (e.g., "vlm" or "pipeline").',
+                            zh_Hans: '用于提取的模型版本（例如，“vlm”或“pipeline”）。'
+                        },
+                        enum: ['pipeline', 'vlm'],
+                        default: 'pipeline'
+                    }
+                },
+                required: []
+            }
+        };
+    }
+    validateConfig(config) {
+        throw new Error('Method not implemented.');
+    }
+    async transformDocuments(documents, config) {
+        const mineru = new MinerUClient(this.configService, config.permissions);
+        const parsedResults = [];
+        for await (const document of documents) {
+            if (mineru.serverType === 'self-hosted') {
+                const { taskId } = await mineru.createTask({
+                    url: document.fileUrl,
+                    filePath: document.filePath,
+                    fileName: document.name,
+                    isOcr: true,
+                    enableFormula: true,
+                    enableTable: true,
+                    // language: 'ch',
+                    // modelVersion: 'vlm'
+                });
+                const result = mineru.getSelfHostedTask(taskId);
+                const parsedResult = await this.resultParser.parseLocalTask(result, taskId, document, config.permissions.fileSystem);
+                parsedResult.id = document.id;
+                parsedResults.push(parsedResult);
+            }
+            else {
+                const { taskId } = await mineru.createTask({
+                    url: document.fileUrl,
+                    isOcr: true,
+                    enableFormula: true,
+                    enableTable: true,
+                    language: 'ch',
+                    modelVersion: 'vlm',
+                    ...omitBy(pick(config, ['isOcr', 'enableFormula', 'enableTable', 'language', 'modelVersion']), isNil)
+                });
+                // Waiting for completion
+                const result = await mineru.waitForTask(taskId, 5 * 60 * 1000, 5000);
+                const parsedResult = await this.resultParser.parseFromUrl(result.full_zip_url, taskId, document, config.permissions.fileSystem);
+                parsedResult.id = document.id;
+                parsedResults.push(parsedResult);
+            }
+        }
+        return parsedResults;
+    }
+};
+__decorate([
+    Inject(MinerUResultParserService),
+    __metadata("design:type", MinerUResultParserService)
+], MinerUTransformerStrategy.prototype, "resultParser", void 0);
+__decorate([
+    Inject(forwardRef(() => ConfigService)),
+    __metadata("design:type", ConfigService)
+], MinerUTransformerStrategy.prototype, "configService", void 0);
+MinerUTransformerStrategy = __decorate([
+    Injectable(),
+    DocumentTransformerStrategy(MinerU)
+], MinerUTransformerStrategy);
+export { MinerUTransformerStrategy };