@helloxiaohu/plugin-mineru 0.1.0 → 0.1.3

package/dist/lib/mineru.tool.js

@@ -3,28 +3,36 @@ import { getCurrentTaskInput } from '@langchain/langgraph';
 import { getErrorMessage } from '@xpert-ai/plugin-sdk';
 import { z } from 'zod';
 import { MinerUClient } from './mineru.client.js';
-import { MinerUIntegration } from './types.js';
-/**
- * Build MinerU PDF parser tool
- * This tool converts PDF files to markdown format using MinerU service
- */
+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 } = input;
-            // Log raw input (mask nothing sensitive here because doc_url is public; avoid logging other fields)
-            console.debug('[MinerU] tool invoked with input', { doc_url, extraKeys: Object.keys(input || {}).filter((k) => k !== 'doc_url') });
+            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');
             }
-            // Get workspace context from current task
             const currentState = getCurrentTaskInput();
             const workspacePath = currentState?.['sys']?.['volume'] ?? '/tmp/xpert';
-            // Use configuration from authorization page (passed via options and defaults parameters)
-            // These values come from the authorization page configuration and are set when the tool is created
             const finalApiUrl = options?.apiUrl || 'https://mineru.net/api/v4';
-            const finalApiKey = options?.apiKey; // apiKey is required and validated in authorization page
-            // Log effective config (mask key) to确认是否拿到了授权页的凭据
+            const finalApiKey = options?.apiKey;
             const maskedKey = finalApiKey && finalApiKey.length > 8
                 ? `${finalApiKey.slice(0, 4)}***${finalApiKey.slice(-4)}`
                 : finalApiKey
@@ -42,42 +50,45 @@ export function buildMinerUTool(configService, resultParser, options, fileSystem
                     modelVersion: defaults?.modelVersion,
                 },
             });
-            // Use configuration values from authorization page (passed via defaults parameter)
-            // Convert string enum values ('true'/'false') to boolean, or use boolean values directly
-            // If undefined, default to true
             const finalIsOcr = defaults?.isOcr === undefined
                 ? true
-                : (typeof defaults.isOcr === 'string' ? defaults.isOcr === 'true' : defaults.isOcr === 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);
+                : 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);
+                : 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: MinerUIntegration,
+                provider: MinerU,
                 options: effectiveOptions,
             };
             const mineruClient = new MinerUClient(configService, {
                 fileSystem,
                 integration,
             });
-            // Determine file name from URL
             let finalFileName = 'document.pdf';
             try {
                 const parsed = new URL(doc_url);
                 finalFileName = parsed.pathname.split('/').pop() || 'document.pdf';
             }
             catch {
-                // ignore
+                // Ignore URL parsing errors.
             }
-            // Create MinerU task
             const { taskId } = await mineruClient.createTask({
                 url: doc_url,
                 fileName: finalFileName,
@@ -86,10 +97,11 @@ export function buildMinerUTool(configService, resultParser, options, fileSystem
                 enableTable: finalEnableTable,
                 language: finalLanguage,
                 modelVersion: finalModelVersion,
+                pageRanges: page_ranges ?? undefined,
+                extraFormats: finalExtraFormats,
             });
             let parsedResult;
             if (mineruClient.serverType === 'self-hosted') {
-                // Self-hosted: get result immediately
                 const taskResult = mineruClient.getSelfHostedTask(taskId);
                 if (!taskResult) {
                     throw new Error('Failed to get MinerU task result');
@@ -101,24 +113,34 @@ export function buildMinerUTool(configService, resultParser, options, fileSystem
                 }, fileSystem);
             }
             else {
-                // Official API: wait for completion
                 const result = await mineruClient.waitForTask(taskId, 5 * 60 * 1000, 5000);
-                parsedResult = await resultParser.parseFromUrl(result.full_zip_url, taskId, {
+                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;
+                }
             }
-            // Build file artifacts from parsed result
             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 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');
+                            ? extension === 'png'
+                                ? 'image/png'
+                                : 'image/jpeg'
+                            : extension === 'md'
+                                ? 'text/markdown'
+                                : 'application/json';
                         fileArtifacts.push({
                             fileName: fileName,
                             filePath: asset.filePath,
@@ -129,11 +151,7 @@ export function buildMinerUTool(configService, resultParser, options, fileSystem
                     }
                 }
             }
-            // Extract markdown content from chunks
-            const markdownContent = parsedResult.chunks
-                ?.map((chunk) => chunk.pageContent)
-                .join('\n\n') || '';
-            // Return full markdown (do NOT truncate). If the platform/UI needs a preview, it can truncate client-side.
+            const markdownContent = parsedResult.chunks?.map((chunk) => chunk.pageContent).join('\n\n') || '';
             return [
                 markdownContent,
                 {
@@ -148,9 +166,14 @@ export function buildMinerUTool(configService, resultParser, options, fileSystem
         }
     }, {
         name: 'mineru_pdf_parser',
-        description: 'Convert PDF files to markdown format using MinerU. Supports OCR, formula recognition, and table extraction. Returns markdown content and extracted files (images, JSON, etc.).',
+        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('PDF URL (required)'),
+            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

@@ -2,15 +2,10 @@ 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';
-/**
- * Configuration for MinerU Toolset
- */
 export interface MinerUToolsetConfig {
-    /**
-     * MinerU API options stored in toolset credentials
-     */
     apiUrl?: string;
     apiKey?: string;
+    extraFormats?: string | string[];
     fileSystem?: XpFileSystem;
     configService?: ConfigService;
     resultParser?: MinerUResultParserService;
@@ -20,31 +15,11 @@ export interface MinerUToolsetConfig {
     language?: 'en' | 'ch';
     modelVersion?: 'pipeline' | 'vlm';
 }
-/**
- * MinerU Toolset implementation
- * Provides PDF to markdown conversion tool using MinerU service
- */
 export declare class MinerUToolset extends BuiltinToolset<StructuredToolInterface, MinerUToolsetConfig> {
     private readonly config;
     tools: any[];
-    /**
-     * Constructor for MinerU Toolset
-     * Accepts config which contains credentials and dependencies
-     * Note: Using 'as any' for params because TBuiltinToolsetParams requires system-provided
-     * properties (tenantId, env) that are added at runtime
-     */
     constructor(config: MinerUToolsetConfig);
-    /**
-     * Validate credentials for MinerU toolset
-     * Note: During authorization phase, credentials may be incomplete.
-     * configService and resultParser are runtime dependencies injected by the strategy.
-     * We don't validate anything here to allow authorization to proceed.
-     */
-    _validateCredentials(credentials: MinerUToolsetConfig): Promise<void>;
-    /**
-     * Initialize tools for MinerU toolset
-     * Creates the PDF parser tool with necessary dependencies
-     */
+    _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

@@ -1 +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;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,yBAAyB,CAAC;IAGzC,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;;;GAGG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,uBAAuB,EAAE,mBAAmB,CAAC;IAC7F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAEpC,KAAK,EAAE,GAAG,EAAE,CAAM;IAE3B;;;;;OAKG;gBACS,MAAM,EAAE,mBAAmB;IAgBvC;;;;;OAKG;IACY,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpF;;;OAGG;IACY,SAAS,IAAI,OAAO,CAAC,uBAAuB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;CA+DzF"}
+{"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

@@ -1,87 +1,40 @@
 import { BuiltinToolset } from '@xpert-ai/plugin-sdk';
 import { buildMinerUTool } from './mineru.tool.js';
-/**
- * MinerU Toolset implementation
- * Provides PDF to markdown conversion tool using MinerU service
- */
 export class MinerUToolset extends BuiltinToolset {
-    /**
-     * Constructor for MinerU Toolset
-     * Accepts config which contains credentials and dependencies
-     * Note: Using 'as any' for params because TBuiltinToolsetParams requires system-provided
-     * properties (tenantId, env) that are added at runtime
-     */
     constructor(config) {
         super('mineru', undefined, config);
-        // Ensure `tools` exists even if upstream BuiltinToolset typings differ across versions.
         this.tools = [];
         this.config = config;
-        // Log config received in constructor (mask apiKey for security)
         const configForLog = { ...config };
         if (configForLog.apiKey) {
-            configForLog.apiKey = configForLog.apiKey.length > 8
-                ? `${configForLog.apiKey.substring(0, 4)}...${configForLog.apiKey.substring(configForLog.apiKey.length - 4)}`
-                : '***';
+            configForLog.apiKey =
+                configForLog.apiKey.length > 8
+                    ? `${configForLog.apiKey.substring(0, 4)}...${configForLog.apiKey.substring(configForLog.apiKey.length - 4)}`
+                    : '***';
         }
-        // Use base class logger (protected access)
         if ('logger' in this && this.logger) {
             this.logger.log(`[MinerU] MinerUToolset constructor received config: ${JSON.stringify(configForLog, null, 2)}`);
         }
     }
-    /**
-     * Validate credentials for MinerU toolset
-     * Note: During authorization phase, credentials may be incomplete.
-     * configService and resultParser are runtime dependencies injected by the strategy.
-     * We don't validate anything here to allow authorization to proceed.
-     */
-    async _validateCredentials(credentials) {
-        // No validation needed during authorization phase
-        // API key validity will be enforced by MinerU server when tool is used
+    async _validateCredentials(_credentials) {
+        // No validation during authorization phase.
     }
-    /**
-     * Initialize tools for MinerU toolset
-     * Creates the PDF parser tool with necessary dependencies
-     */
     async initTools() {
-        const { configService, resultParser, apiUrl, apiKey, fileSystem, isOcr, enableFormula, enableTable, language, modelVersion } = this.config;
-        // Log config before destructuring
-        const configKeys = Object.keys(this.config);
-        const hasApiKey = 'apiKey' in this.config;
-        const apiKeyValue = this.config.apiKey;
-        const maskedApiKey = apiKeyValue
-            ? (apiKeyValue.length > 8 ? `${apiKeyValue.substring(0, 4)}...${apiKeyValue.substring(apiKeyValue.length - 4)}` : '***')
-            : 'missing';
-        // Use base class logger (protected access)
-        if ('logger' in this && this.logger) {
-            this.logger.log(`[MinerU] MinerUToolset.initTools() - config keys: ${configKeys.join(', ')}, hasApiKey: ${hasApiKey}, apiKey: ${maskedApiKey}`);
-            this.logger.log(`[MinerU] MinerUToolset.initTools() - destructured apiKey: ${apiKey ? (apiKey.length > 8 ? `${apiKey.substring(0, 4)}...${apiKey.substring(apiKey.length - 4)}` : '***') : 'missing'}`);
-        }
+        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');
         }
-        // Use configuration from authorization page
-        // apiUrl: use provided value or default to official server URL
         const finalApiUrl = apiUrl || 'https://mineru.net/api/v4';
-        // Convert string enum values to boolean (compatible with 'true'/'false' strings and boolean values)
-        // Use provided values from authorization page, or default to true
         const finalIsOcr = isOcr === 'true' || isOcr === true;
         const finalEnableFormula = enableFormula === 'true' || enableFormula === true;
         const finalEnableTable = enableTable === 'true' || enableTable === true;
-        // Use provided values from authorization page, or use defaults
         const finalLanguage = language || 'ch';
         const finalModelVersion = modelVersion || 'pipeline';
-        // Log what we're passing to buildMinerUTool
-        const maskedFinalApiKey = apiKey
-            ? (apiKey.length > 8 ? `${apiKey.substring(0, 4)}...${apiKey.substring(apiKey.length - 4)}` : '***')
-            : 'missing';
-        // Use base class logger (protected access)
-        if ('logger' in this && this.logger) {
-            this.logger.log(`[MinerU] MinerUToolset.initTools() - passing to buildMinerUTool: apiUrl=${finalApiUrl}, apiKey=${maskedFinalApiKey}`);
-        }
         this.tools = [
             buildMinerUTool(configService, resultParser, {
                 apiUrl: finalApiUrl,
-                apiKey, // apiKey is required and validated in authorization page
+                apiKey,
+                extraFormats,
             }, fileSystem, {
                 isOcr: finalIsOcr,
                 enableFormula: finalEnableFormula,

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,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;IAqGI,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;CA4DH"}
+{"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"}

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

@@ -21,6 +21,7 @@ let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResult
         const metadata = {
             parser: MinerU,
             taskId,
+            fullZipUrl,
         };
         // 2. Unzip the file
         const zipEntries = [];
@@ -36,61 +37,43 @@ let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResult
             zipEntries.push({ entryName: entry.path, data });
             const fileName = entry.path;
             const filePath = join(document.folder || '', entry.path);
-            // If platform didn't provide filesystem permission, still parse markdown but skip persisting files.
-            // This avoids runtime crashes like: "Cannot read properties of undefined (reading 'writeFile')".
-            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;
-                }
+            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 {
-                // 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;
-                }
+            else if (fileName.endsWith('origin.pdf')) {
+                metadata.originPdfUrl = fileName;
             }
         }
         metadata.assets = assets;
@@ -119,24 +102,13 @@ let MinerUResultParserService = MinerUResultParserService_1 = class MinerUResult
         const pathMap = new Map();
         for (const image of result.images) {
             const filePath = join(document.folder || '', 'images', image.name);
-            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 {
-                // Fallback: keep images as data URLs so markdown can still render without filesystem permission
-                pathMap.set(`images/${image.name}`, image.dataUrl);
-                assets.push({
-                    type: 'image',
-                    url: image.dataUrl,
-                    filePath: filePath,
-                });
-            }
+            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({

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

@@ -85,6 +85,17 @@ export declare class MinerUTransformerStrategy implements IDocumentTransformerSt
                     enum: string[];
                     default: string;
                 };
+                pageRanges: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                };
             };
             required: any[];
         };

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

@@ -1 +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,EAA8C,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEjG,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"}
+{"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,EAA0C,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE7F,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmF1B;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;CAiEzD"}

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

@@ -5,13 +5,13 @@ 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, MinerUIntegration, MinerUTransformer } from './types.js';
+import { icon, MinerU } from './types.js';
 let MinerUTransformerStrategy = class MinerUTransformerStrategy {
     constructor() {
         this.permissions = [
             {
                 type: 'integration',
-                service: MinerUIntegration,
+                service: MinerU,
                 description: 'Access to MinerU system integrations'
             },
             {
@@ -21,7 +21,7 @@ let MinerUTransformerStrategy = class MinerUTransformerStrategy {
             }
         ];
         this.meta = {
-            name: MinerUTransformer,
+            name: MinerU,
             label: {
                 en_US: 'MinerU',
                 zh_Hans: 'MinerU'
@@ -99,6 +99,17 @@ let MinerUTransformerStrategy = class MinerUTransformerStrategy {
                         },
                         enum: ['pipeline', 'vlm'],
                         default: 'pipeline'
+                    },
+                    pageRanges: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Page Ranges',
+                            zh_Hans: '页码范围'
+                        },
+                        description: {
+                            en_US: 'Page ranges like "2,4-6" or "2--2" (official API only).',
+                            zh_Hans: '页码范围，例如 "2,4-6" 或 "2--2"（仅官方 API）。'
+                        }
                     }
                 },
                 required: []
@@ -111,6 +122,7 @@ let MinerUTransformerStrategy = class MinerUTransformerStrategy {
     async transformDocuments(documents, config) {
         const mineru = new MinerUClient(this.configService, config.permissions);
         const parsedResults = [];
+        const integrationOptions = config.permissions?.integration?.options;
         for await (const document of documents) {
             if (mineru.serverType === 'self-hosted') {
                 const { taskId } = await mineru.createTask({
@@ -125,8 +137,12 @@ let MinerUTransformerStrategy = class MinerUTransformerStrategy {
                 });
                 const result = mineru.getSelfHostedTask(taskId);
                 const parsedResult = await this.resultParser.parseLocalTask(result, taskId, document, config.permissions.fileSystem);
-                parsedResult.id = document.id;
-                parsedResults.push(parsedResult);
+                // Convert parsedResult to IKnowledgeDocument format
+                parsedResults.push({
+                    id: document.id,
+                    chunks: parsedResult.chunks,
+                    metadata: parsedResult.metadata
+                });
             }
             else {
                 const { taskId } = await mineru.createTask({
@@ -136,13 +152,19 @@ let MinerUTransformerStrategy = class MinerUTransformerStrategy {
                     enableTable: true,
                     language: 'ch',
                     modelVersion: 'vlm',
-                    ...omitBy(pick(config, ['isOcr', 'enableFormula', 'enableTable', 'language', 'modelVersion']), isNil)
+                    pageRanges: config.pageRanges,
+                    extraFormats: integrationOptions?.extraFormats,
+                    ...omitBy(pick(config, ['isOcr', 'enableFormula', 'enableTable', 'language', 'modelVersion', 'pageRanges']), 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);
+                // Convert parsedResult to IKnowledgeDocument format
+                parsedResults.push({
+                    id: document.id,
+                    chunks: parsedResult.chunks,
+                    metadata: parsedResult.metadata
+                });
             }
         }
         return parsedResults;
@@ -158,6 +180,6 @@ __decorate([
 ], MinerUTransformerStrategy.prototype, "configService", void 0);
 MinerUTransformerStrategy = __decorate([
     Injectable(),
-    DocumentTransformerStrategy(MinerUTransformer)
+    DocumentTransformerStrategy(MinerU)
 ], MinerUTransformerStrategy);
 export { MinerUTransformerStrategy };