@helloxiaohu/plugin-mineru 0.1.2 → 0.1.4

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

@@ -0,0 +1,218 @@
+import { ConfigService } from '@nestjs/config';
+import { BuiltinToolset, IToolsetStrategy, FileSystemPermission, ISchemaSecretField } from '@xpert-ai/plugin-sdk';
+import { MinerUResultParserService } from './result-parser.service.js';
+import { MinerUToolsetConfig } from './mineru.toolset.js';
+export declare class MinerUToolsetStrategy implements IToolsetStrategy<MinerUToolsetConfig> {
+    private readonly configService;
+    private readonly resultParser;
+    meta: {
+        author: string;
+        tags: string[];
+        name: string;
+        label: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        description: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            type: string;
+            value: string;
+            svg: string;
+            color: string;
+        };
+        configSchema: {
+            type: string;
+            properties: {
+                apiUrl: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: string;
+                };
+                apiKey: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    'x-ui': ISchemaSecretField;
+                };
+                isOcr: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                    'x-ui': {
+                        enumLabels: {
+                            true: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                            false: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                        };
+                    };
+                };
+                enableFormula: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                    'x-ui': {
+                        enumLabels: {
+                            true: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                            false: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                        };
+                    };
+                };
+                enableTable: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                    'x-ui': {
+                        enumLabels: {
+                            true: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                            false: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                        };
+                    };
+                };
+                language: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                    'x-ui': {
+                        enumLabels: {
+                            en: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                            ch: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                        };
+                    };
+                };
+                modelVersion: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    enum: string[];
+                    default: string;
+                    'x-ui': {
+                        enumLabels: {
+                            pipeline: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                            vlm: {
+                                en_US: string;
+                                zh_Hans: string;
+                            };
+                        };
+                    };
+                };
+                extraFormats: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                };
+            };
+            required: string[];
+        };
+    };
+    readonly permissions: FileSystemPermission[];
+    constructor(configService: ConfigService, resultParser: MinerUResultParserService);
+    validateConfig(config: MinerUToolsetConfig | null | undefined): Promise<void>;
+    create(config: any): Promise<BuiltinToolset>;
+    createTools(): import("@langchain/core/tools").DynamicStructuredTool<import("zod").ZodObject<{
+        doc_url: import("zod").ZodString;
+        page_ranges: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        doc_url?: string;
+        page_ranges?: string;
+    }, {
+        doc_url?: string;
+        page_ranges?: string;
+    }>, {
+        doc_url?: string;
+        page_ranges?: string;
+    }, {
+        doc_url?: string;
+        page_ranges?: string;
+    }, (string | {
+        files: any[];
+        taskId: string;
+        metadata: any;
+    })[]>[];
+}
+//# sourceMappingURL=mineru-toolset.strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mineru-toolset.strategy.d.ts","sourceRoot":"","sources":["../../src/lib/mineru-toolset.strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EACL,cAAc,EACd,gBAAgB,EAEhB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAiB,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AASzE,qBAEa,qBAAsB,YAAW,gBAAgB,CAAC,mBAAmB,CAAC;IA6M/E,OAAO,CAAC,QAAQ,CAAC,aAAa;IAE9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IA9M/B,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA4Ca,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoJjC;IAEF,QAAQ,CAAC,WAAW,yBAMlB;gBAIiB,aAAa,EAAE,aAAa,EAE5B,YAAY,EAAE,yBAAyB;IAG1D,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvE,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC;IAwBlD,WAAW;;;;;;;;;;;;;;;;;;;;CAiBZ"}

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

@@ -0,0 +1,261 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Injectable, forwardRef, Inject } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ToolsetStrategy, } from '@xpert-ai/plugin-sdk';
+import { MinerUResultParserService } from './result-parser.service.js';
+import { MinerUToolset } from './mineru.toolset.js';
+import { MinerU, icon } from './types.js';
+import { buildMinerUTool } from './mineru.tool.js';
+let MinerUToolsetStrategy = class MinerUToolsetStrategy {
+    constructor(configService, resultParser) {
+        this.configService = configService;
+        this.resultParser = resultParser;
+        this.meta = {
+            author: 'Xpert AI',
+            tags: ['pdf', 'markdown', 'parser', 'ocr', 'mineru', 'document', 'extraction'],
+            name: MinerU,
+            label: {
+                en_US: 'MinerU PDF Parser',
+                zh_Hans: 'MinerU PDF 解析器',
+            },
+            description: {
+                en_US: 'Convert documents to markdown format using MinerU. Supports OCR, formula recognition, and table extraction.',
+                zh_Hans: '使用 MinerU 将文档转换为 Markdown 格式。支持 OCR、公式识别和表格提取。',
+            },
+            icon: {
+                type: 'svg',
+                value: icon,
+                svg: icon,
+                color: '#14b8a6',
+            },
+            configSchema: {
+                type: 'object',
+                properties: {
+                    apiUrl: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Base URL',
+                            zh_Hans: 'Base URL',
+                        },
+                        description: {
+                            en_US: 'MinerU API base url. Official: https://mineru.net/api/v4',
+                            zh_Hans: 'MinerU 服务地址。官方： https://mineru.net/api/v4',
+                        },
+                        default: 'https://mineru.net/api/v4',
+                    },
+                    apiKey: {
+                        type: 'string',
+                        title: {
+                            en_US: 'API Key',
+                            zh_Hans: 'API Key',
+                        },
+                        description: {
+                            en_US: 'The API Key of the MinerU server (required)',
+                            zh_Hans: 'MinerU 服务令牌（必填）',
+                        },
+                        'x-ui': {
+                            component: 'secretInput',
+                            label: 'API Key',
+                            placeholder: 'MinerU API Key',
+                            revealable: true,
+                            maskSymbol: '*',
+                            persist: true,
+                        },
+                    },
+                    isOcr: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Enable OCR',
+                            zh_Hans: '启用 OCR',
+                        },
+                        description: {
+                            en_US: 'Enable OCR for image-based documents',
+                            zh_Hans: '为基于图像的文档启用 OCR',
+                        },
+                        enum: ['true', 'false'],
+                        default: 'true',
+                        'x-ui': {
+                            enumLabels: {
+                                'true': {
+                                    en_US: 'Enabled',
+                                    zh_Hans: '启用',
+                                },
+                                'false': {
+                                    en_US: 'Disabled',
+                                    zh_Hans: '禁用',
+                                },
+                            },
+                        },
+                    },
+                    enableFormula: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Enable Formula Recognition',
+                            zh_Hans: '启用公式识别',
+                        },
+                        description: {
+                            en_US: 'Enable formula recognition',
+                            zh_Hans: '启用公式识别',
+                        },
+                        enum: ['true', 'false'],
+                        default: 'true',
+                        'x-ui': {
+                            enumLabels: {
+                                'true': {
+                                    en_US: 'Enabled',
+                                    zh_Hans: '启用',
+                                },
+                                'false': {
+                                    en_US: 'Disabled',
+                                    zh_Hans: '禁用',
+                                },
+                            },
+                        },
+                    },
+                    enableTable: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Enable Table Recognition',
+                            zh_Hans: '启用表格识别',
+                        },
+                        description: {
+                            en_US: 'Enable table recognition',
+                            zh_Hans: '启用表格识别',
+                        },
+                        enum: ['true', 'false'],
+                        default: 'true',
+                        'x-ui': {
+                            enumLabels: {
+                                'true': {
+                                    en_US: 'Enabled',
+                                    zh_Hans: '启用',
+                                },
+                                'false': {
+                                    en_US: 'Disabled',
+                                    zh_Hans: '禁用',
+                                },
+                            },
+                        },
+                    },
+                    language: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Document Language',
+                            zh_Hans: '文档语言',
+                        },
+                        description: {
+                            en_US: 'Document language: "en" for English, "ch" for Chinese (default: "ch")',
+                            zh_Hans: '文档语言："en" 表示英语，"ch" 表示中文（默认："ch"）',
+                        },
+                        enum: ['en', 'ch'],
+                        default: 'ch',
+                        'x-ui': {
+                            enumLabels: {
+                                'en': {
+                                    en_US: 'en',
+                                    zh_Hans: '英文',
+                                },
+                                'ch': {
+                                    en_US: 'ch',
+                                    zh_Hans: '中文',
+                                },
+                            },
+                        },
+                    },
+                    modelVersion: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Model Version',
+                            zh_Hans: '模型版本',
+                        },
+                        description: {
+                            en_US: 'Model version: "pipeline" or "vlm" (default: "pipeline")',
+                            zh_Hans: '模型版本："pipeline" 或 "vlm"（默认："pipeline"）',
+                        },
+                        enum: ['pipeline', 'vlm'],
+                        default: 'pipeline',
+                        'x-ui': {
+                            enumLabels: {
+                                'pipeline': {
+                                    en_US: 'pipeline',
+                                    zh_Hans: 'pipeline',
+                                },
+                                'vlm': {
+                                    en_US: 'vlm',
+                                    zh_Hans: 'vlm',
+                                },
+                            },
+                        },
+                    },
+                    extraFormats: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Extra Formats',
+                            zh_Hans: '额外输出格式',
+                        },
+                        description: {
+                            en_US: 'Optional extra formats, comma-separated (docx, html, latex).',
+                            zh_Hans: '可选额外输出格式，逗号分隔（docx、html、latex）。',
+                        },
+                    },
+                },
+                required: ['apiKey'],
+            },
+        };
+        this.permissions = [
+            {
+                type: 'filesystem',
+                operations: ['read', 'write', 'list'],
+                scope: [],
+            },
+        ];
+    }
+    validateConfig(config) {
+        if (!config) {
+            return Promise.resolve();
+        }
+        if (!config.apiKey) {
+            throw new Error('MinerU apiKey is required');
+        }
+        return Promise.resolve();
+    }
+    async create(config) {
+        const toolset = config && typeof config === 'object' && 'credentials' in config
+            ? config
+            : null;
+        const creds = toolset?.credentials ?? config ?? {};
+        const configWithDependencies = {
+            apiUrl: creds.apiUrl,
+            apiKey: creds.apiKey,
+            extraFormats: creds.extraFormats,
+            isOcr: creds.isOcr,
+            enableFormula: creds.enableFormula,
+            enableTable: creds.enableTable,
+            language: creds.language,
+            modelVersion: creds.modelVersion,
+            configService: this.configService,
+            resultParser: this.resultParser,
+        };
+        return new MinerUToolset(configWithDependencies);
+    }
+    createTools() {
+        return [
+            buildMinerUTool(this.configService, this.resultParser, undefined, undefined, {
+                isOcr: true,
+                enableFormula: true,
+                enableTable: true,
+                language: 'ch',
+                modelVersion: 'pipeline',
+            }),
+        ];
+    }
+};
+MinerUToolsetStrategy = __decorate([
+    Injectable(),
+    ToolsetStrategy(MinerU),
+    __param(0, Inject(forwardRef(() => ConfigService))),
+    __param(1, Inject(MinerUResultParserService)),
+    __metadata("design:paramtypes", [ConfigService,
+        MinerUResultParserService])
+], MinerUToolsetStrategy);
+export { MinerUToolsetStrategy };

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

@@ -1 +1 @@
-{"version":3,"file":"mineru.plugin.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAO/F,qBAiBa,YAAa,YAAW,kBAAkB,EAAE,gBAAgB;IAExE,OAAO,CAAC,UAAU,CAAQ;IAE1B;;OAEG;IACH,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC;;OAEG;IACH,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKvC"}
+{"version":3,"file":"mineru.plugin.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAQ/F,qBAkBa,YAAa,YAAW,kBAAkB,EAAE,gBAAgB;IAExE,OAAO,CAAC,UAAU,CAAQ;IAE1B;;OAEG;IACH,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC;;OAEG;IACH,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKvC"}

package/dist/lib/mineru.plugin.js

@@ -7,6 +7,7 @@ import { MinerUTransformerStrategy } from './transformer-mineru.strategy.js';
 import { MinerUResultParserService } from './result-parser.service.js';
 import { MinerUIntegrationStrategy } from './integration.strategy.js';
 import { MinerUController } from './mineru.controller.js';
+import { MinerUToolsetStrategy } from './mineru-toolset.strategy.js';
 let MinerUPlugin = MinerUPlugin_1 = class MinerUPlugin {
     constructor() {
         // We disable by default additional logging for each event to avoid cluttering the logs
@@ -41,6 +42,7 @@ MinerUPlugin = MinerUPlugin_1 = __decorate([
             MinerUIntegrationStrategy,
             MinerUTransformerStrategy,
             MinerUResultParserService,
+            MinerUToolsetStrategy,
         ],
         controllers: [
             MinerUController

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

@@ -0,0 +1,33 @@
+import { XpFileSystem } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+import { ConfigService } from '@nestjs/config';
+import { MinerUResultParserService } from './result-parser.service.js';
+import { MinerUIntegrationOptions } from './types.js';
+export interface MinerUToolDefaults {
+    isOcr?: boolean | string;
+    enableFormula?: boolean | string;
+    enableTable?: boolean | string;
+    language?: 'en' | 'ch';
+    modelVersion?: 'pipeline' | 'vlm';
+}
+export declare function buildMinerUTool(configService: ConfigService, resultParser: MinerUResultParserService, options?: MinerUIntegrationOptions, fileSystem?: XpFileSystem, defaults?: MinerUToolDefaults): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    doc_url: z.ZodString;
+    page_ranges: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    doc_url?: string;
+    page_ranges?: string;
+}, {
+    doc_url?: string;
+    page_ranges?: string;
+}>, {
+    doc_url?: string;
+    page_ranges?: string;
+}, {
+    doc_url?: string;
+    page_ranges?: string;
+}, (string | {
+    files: any[];
+    taskId: string;
+    metadata: any;
+})[]>;
+//# sourceMappingURL=mineru.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mineru.tool.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.tool.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,OAAO,EAAU,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC;CACnC;AAiBD,wBAAgB,eAAe,CAC7B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,yBAAyB,EACvC,OAAO,CAAC,EAAE,wBAAwB,EAClC,UAAU,CAAC,EAAE,YAAY,EACzB,QAAQ,CAAC,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;MAsM9B"}

package/dist/lib/mineru.tool.js

@@ -0,0 +1,180 @@
+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';
+import { MinerU } from './types.js';
+function normalizeExtraFormats(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const formats = value.map((item) => String(item).trim()).filter(Boolean);
+        return formats.length ? formats : undefined;
+    }
+    const formats = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return formats.length ? formats : undefined;
+}
+export function buildMinerUTool(configService, resultParser, options, fileSystem, defaults) {
+    return tool(async (input) => {
+        try {
+            const { doc_url, page_ranges } = input;
+            console.debug('[MinerU] tool invoked with input', {
+                doc_url,
+                extraKeys: Object.keys(input || {}).filter((key) => key !== 'doc_url'),
+            });
+            if (!doc_url) {
+                throw new Error('doc_url is required');
+            }
+            const currentState = getCurrentTaskInput();
+            const workspacePath = currentState?.['sys']?.['volume'] ?? '/tmp/xpert';
+            const finalApiUrl = options?.apiUrl || 'https://mineru.net/api/v4';
+            const finalApiKey = options?.apiKey;
+            const maskedKey = finalApiKey && finalApiKey.length > 8
+                ? `${finalApiKey.slice(0, 4)}***${finalApiKey.slice(-4)}`
+                : finalApiKey
+                    ? 'provided'
+                    : 'missing';
+            console.debug('[MinerU] buildMinerUTool config', {
+                fromOptions: Boolean(options),
+                apiUrl: finalApiUrl,
+                apiKey: maskedKey,
+                defaults: {
+                    isOcr: defaults?.isOcr,
+                    enableFormula: defaults?.enableFormula,
+                    enableTable: defaults?.enableTable,
+                    language: defaults?.language,
+                    modelVersion: defaults?.modelVersion,
+                },
+            });
+            const finalIsOcr = defaults?.isOcr === undefined
+                ? true
+                : typeof defaults.isOcr === 'string'
+                    ? defaults.isOcr === 'true'
+                    : defaults.isOcr === true;
+            const finalEnableFormula = defaults?.enableFormula === undefined
+                ? true
+                : typeof defaults.enableFormula === 'string'
+                    ? defaults.enableFormula === 'true'
+                    : defaults.enableFormula === true;
+            const finalEnableTable = defaults?.enableTable === undefined
+                ? true
+                : typeof defaults.enableTable === 'string'
+                    ? defaults.enableTable === 'true'
+                    : defaults.enableTable === true;
+            const finalLanguage = defaults?.language || 'ch';
+            const finalModelVersion = defaults?.modelVersion || 'pipeline';
+            const finalExtraFormats = normalizeExtraFormats(options?.extraFormats);
+            const effectiveOptions = {
+                apiUrl: finalApiUrl,
+                apiKey: finalApiKey,
+                extraFormats: finalExtraFormats,
+            };
+            const integration = {
+                provider: MinerU,
+                options: effectiveOptions,
+            };
+            const mineruClient = new MinerUClient(configService, {
+                fileSystem,
+                integration,
+            });
+            let finalFileName = 'document.pdf';
+            try {
+                const parsed = new URL(doc_url);
+                finalFileName = parsed.pathname.split('/').pop() || 'document.pdf';
+            }
+            catch {
+                // Ignore URL parsing errors.
+            }
+            const { taskId } = await mineruClient.createTask({
+                url: doc_url,
+                fileName: finalFileName,
+                isOcr: finalIsOcr,
+                enableFormula: finalEnableFormula,
+                enableTable: finalEnableTable,
+                language: finalLanguage,
+                modelVersion: finalModelVersion,
+                pageRanges: page_ranges ?? undefined,
+                extraFormats: finalExtraFormats,
+            });
+            let parsedResult;
+            if (mineruClient.serverType === 'self-hosted') {
+                const taskResult = mineruClient.getSelfHostedTask(taskId);
+                if (!taskResult) {
+                    throw new Error('Failed to get MinerU task result');
+                }
+                parsedResult = await resultParser.parseLocalTask(taskResult, taskId, {
+                    fileUrl: doc_url,
+                    name: finalFileName,
+                    folder: workspacePath,
+                }, fileSystem);
+            }
+            else {
+                const result = await mineruClient.waitForTask(taskId, 5 * 60 * 1000, 5000);
+                const fullZipUrl = result.full_zip_url;
+                parsedResult = await resultParser.parseFromUrl(fullZipUrl, taskId, {
+                    fileUrl: doc_url,
+                    name: finalFileName,
+                    folder: workspacePath,
+                }, fileSystem);
+                if (fullZipUrl) {
+                    parsedResult.metadata = parsedResult.metadata ?? {};
+                    parsedResult.metadata.fullZipUrl = parsedResult.metadata.fullZipUrl ?? fullZipUrl;
+                    parsedResult.metadata.full_zip_url = parsedResult.metadata.full_zip_url ?? fullZipUrl;
+                }
+            }
+            const fileArtifacts = [];
+            if (parsedResult.metadata?.assets) {
+                for (const asset of parsedResult.metadata.assets) {
+                    if (asset.type === 'file' || asset.type === 'image') {
+                        const fileName = asset.filePath?.split(/[/\\]/).pop() ||
+                            asset.url?.split('/').pop() ||
+                            'file';
+                        const extension = fileName.split('.').pop()?.toLowerCase() || 'md';
+                        const mimeType = asset.type === 'image'
+                            ? extension === 'png'
+                                ? 'image/png'
+                                : 'image/jpeg'
+                            : extension === 'md'
+                                ? 'text/markdown'
+                                : 'application/json';
+                        fileArtifacts.push({
+                            fileName: fileName,
+                            filePath: asset.filePath,
+                            fileUrl: asset.url,
+                            mimeType: mimeType,
+                            extension: extension,
+                        });
+                    }
+                }
+            }
+            const markdownContent = parsedResult.chunks?.map((chunk) => chunk.pageContent).join('\n\n') || '';
+            return [
+                markdownContent,
+                {
+                    files: fileArtifacts,
+                    taskId,
+                    metadata: parsedResult.metadata,
+                },
+            ];
+        }
+        catch (error) {
+            throw new Error(`MinerU processing failed: ${getErrorMessage(error)}`);
+        }
+    }, {
+        name: 'mineru_pdf_parser',
+        description: 'Convert documents to markdown using MinerU. Supports OCR, formula recognition, and table extraction. Returns markdown content and extracted files.',
+        schema: z.object({
+            doc_url: z.string().min(1).describe('Document URL (required)'),
+            page_ranges: z
+                .string()
+                .optional()
+                .nullable()
+                .describe('Page ranges like "2,4-6" or "2--2"'),
+        }),
+        responseFormat: 'content_and_artifact',
+    });
+}

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

@@ -0,0 +1,25 @@
+import { StructuredToolInterface, ToolSchemaBase } from '@langchain/core/tools';
+import { BuiltinToolset, XpFileSystem } from '@xpert-ai/plugin-sdk';
+import { ConfigService } from '@nestjs/config';
+import { MinerUResultParserService } from './result-parser.service.js';
+export interface MinerUToolsetConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    extraFormats?: string | string[];
+    fileSystem?: XpFileSystem;
+    configService?: ConfigService;
+    resultParser?: MinerUResultParserService;
+    isOcr?: boolean | string;
+    enableFormula?: boolean | string;
+    enableTable?: boolean | string;
+    language?: 'en' | 'ch';
+    modelVersion?: 'pipeline' | 'vlm';
+}
+export declare class MinerUToolset extends BuiltinToolset<StructuredToolInterface, MinerUToolsetConfig> {
+    private readonly config;
+    tools: any[];
+    constructor(config: MinerUToolsetConfig);
+    _validateCredentials(_credentials: MinerUToolsetConfig): Promise<void>;
+    initTools(): Promise<StructuredToolInterface<ToolSchemaBase, any, any>[]>;
+}
+//# sourceMappingURL=mineru.toolset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mineru.toolset.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.toolset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAIvE,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACjC,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,UAAU,GAAG,KAAK,CAAC;CACnC;AAED,qBAAa,aAAc,SAAQ,cAAc,CAAC,uBAAuB,EAAE,mBAAmB,CAAC;IAC7F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IACpC,KAAK,EAAE,GAAG,EAAE,CAAM;gBAEf,MAAM,EAAE,mBAAmB;IAiBxB,oBAAoB,CAAC,YAAY,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAItE,SAAS,IAAI,OAAO,CAAC,uBAAuB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;CA+CzF"}

package/dist/lib/mineru.toolset.js

@@ -0,0 +1,48 @@
+import { BuiltinToolset } from '@xpert-ai/plugin-sdk';
+import { buildMinerUTool } from './mineru.tool.js';
+export class MinerUToolset extends BuiltinToolset {
+    constructor(config) {
+        super('mineru', undefined, config);
+        this.tools = [];
+        this.config = config;
+        const configForLog = { ...config };
+        if (configForLog.apiKey) {
+            configForLog.apiKey =
+                configForLog.apiKey.length > 8
+                    ? `${configForLog.apiKey.substring(0, 4)}...${configForLog.apiKey.substring(configForLog.apiKey.length - 4)}`
+                    : '***';
+        }
+        if ('logger' in this && this.logger) {
+            this.logger.log(`[MinerU] MinerUToolset constructor received config: ${JSON.stringify(configForLog, null, 2)}`);
+        }
+    }
+    async _validateCredentials(_credentials) {
+        // No validation during authorization phase.
+    }
+    async initTools() {
+        const { configService, resultParser, apiUrl, apiKey, extraFormats, fileSystem, isOcr, enableFormula, enableTable, language, modelVersion, } = this.config;
+        if (!configService || !resultParser) {
+            throw new Error('ConfigService and MinerUResultParserService are required');
+        }
+        const finalApiUrl = apiUrl || 'https://mineru.net/api/v4';
+        const finalIsOcr = isOcr === 'true' || isOcr === true;
+        const finalEnableFormula = enableFormula === 'true' || enableFormula === true;
+        const finalEnableTable = enableTable === 'true' || enableTable === true;
+        const finalLanguage = language || 'ch';
+        const finalModelVersion = modelVersion || 'pipeline';
+        this.tools = [
+            buildMinerUTool(configService, resultParser, {
+                apiUrl: finalApiUrl,
+                apiKey,
+                extraFormats,
+            }, fileSystem, {
+                isOcr: finalIsOcr,
+                enableFormula: finalEnableFormula,
+                enableTable: finalEnableTable,
+                language: finalLanguage,
+                modelVersion: finalModelVersion,
+            }),
+        ];
+        return this.tools;
+    }
+}

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

@@ -4,12 +4,12 @@ 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<{
+    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<{
+    parseLocalTask(result: MineruSelfHostedTaskResult, taskId: string, document: Partial<IKnowledgeDocument>, fileSystem?: XpFileSystem): Promise<{
         id?: string;
         chunks: Document<ChunkMetadata>[];
         metadata: MinerUDocumentMetadata;

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

@@ -1 +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;IAsFI,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"}
+{"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,CAAC,EAAE,YAAY,GACxB,OAAO,CAAC;QACT,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAClC,QAAQ,EAAE,sBAAsB,CAAC;KAClC,CAAC;IAmGI,cAAc,CAClB,MAAM,EAAE,0BAA0B,EAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,UAAU,CAAC,EAAE,YAAY,GACxB,OAAO,CAAC;QACT,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAClC,QAAQ,EAAE,sBAAsB,CAAC;KAClC,CAAC;CA2DH"}

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

@@ -37,43 +37,59 @@ let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResult
             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,
-                });
+            if (fileSystem) {
+                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;
+                }
             }
-            else if (fileName.endsWith('origin.pdf')) {
-                metadata.originPdfUrl = fileName;
+            else {
+                // Still extract key metadata & markdown without writing to filesystem.
+                if (fileName.endsWith('layout.json')) {
+                    layoutJson = JSON.parse(data.toString('utf-8'));
+                    metadata.mineruBackend = layoutJson?._backend;
+                    metadata.mineruVersion = layoutJson?._version_name;
+                }
+                else if (fileName.endsWith('full.md')) {
+                    fullMd = data.toString('utf-8');
+                }
+                else if (fileName.endsWith('origin.pdf')) {
+                    metadata.originPdfUrl = fileName;
+                }
             }
         }
         metadata.assets = assets;
@@ -102,13 +118,23 @@ let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResult
         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 (fileSystem) {
+                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,
+                });
+            }
+            else {
+                pathMap.set(`images/${image.name}`, image.dataUrl);
+                assets.push({
+                    type: 'image',
+                    url: image.dataUrl,
+                    filePath: filePath,
+                });
+            }
         }
         if (result.sourceUrl) {
             assets.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helloxiaohu/plugin-mineru",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "MinerU document converter plugin for Xpert AI platform",
   "license": "AGPL-3.0",
   "repository": {