@helloxiaohu/plugin-mineru 0.1.0 → 0.1.2

package/dist/lib/mineru.client.js

@@ -3,7 +3,7 @@ import { getErrorMessage } from '@xpert-ai/plugin-sdk';
 import axios from 'axios';
 import FormData from 'form-data';
 import { randomUUID } from 'crypto';
-import { basename } from 'path';
+import { basename, isAbsolute, join as pathJoin } from 'path';
 import fs from 'fs';
 import { ENV_MINERU_API_BASE_URL, ENV_MINERU_API_TOKEN, ENV_MINERU_SERVER_TYPE, } from './types.js';
 const DEFAULT_OFFICIAL_BASE_URL = 'https://mineru.net/api/v4';
@@ -17,26 +17,13 @@ export class MinerUClient {
         this.logger = new Logger(MinerUClient.name);
         this.localTasks = new Map();
         const integration = this.permissions?.integration;
-        // First, resolve credentials without depending on serverType
+        this.serverType = this.resolveServerType(integration);
         const { baseUrl, token } = this.resolveCredentials(integration);
-        const maskedToken = token && token.length > 8
-            ? `${token.slice(0, 4)}***${token.slice(-4)}`
-            : token
-                ? 'provided'
-                : 'missing';
-        this.logger.debug('[MinerU] MinerUClient credentials resolved', {
-            hasIntegration: Boolean(integration),
-            apiUrl: baseUrl,
-            token: maskedToken,
-            serverTypeFromUrl: this.resolveServerTypeFromUrl(baseUrl || '', integration),
-        });
         if (!baseUrl) {
             throw new Error('MinerU base URL is required');
         }
         this.baseUrl = this.normalizeBaseUrl(baseUrl);
         this.token = token;
-        // Automatically determine serverType from URL: official if it's the official URL, otherwise self-hosted
-        this.serverType = this.resolveServerTypeFromUrl(this.baseUrl, integration);
         if (this.serverType === 'official' && !this.token) {
             throw new Error('MinerU official API requires an access token');
         }
@@ -159,13 +146,7 @@ export class MinerUClient {
         const start = Date.now();
         while (true) {
             const result = await this.getTaskResult(taskId);
-            this.logger.debug('[MinerU] waiting task result', {
-                taskId,
-                hasZip: Boolean(result?.full_zip_url),
-                hasUrl: Boolean(result?.full_url),
-                hasContent: Boolean(result?.content),
-                status: result?.status,
-            });
+            this.logger.debug(`MinerU waiting task result: ${JSON.stringify(result)}`);
             if (result?.full_zip_url || result?.full_url || result?.content || result?.status === 'done') {
                 return result;
             }
@@ -180,42 +161,34 @@ export class MinerUClient {
             throw new Error(`${feature} is only supported for official MinerU deployments`);
         }
     }
-    /**
-     * Automatically determine serverType from URL
-     * Returns 'official' if URL is the official address (https://mineru.net/api/v4), otherwise 'self-hosted'
-     */
-    resolveServerTypeFromUrl(baseUrl, integration) {
-        // Prefer explicitly specified serverType (backward compatibility)
+    resolveServerType(integration) {
         const integrationType = this.readIntegrationOptions(integration)?.serverType;
         if (integrationType === 'self-hosted' || integrationType === 'official') {
             return integrationType;
         }
-        // Check environment variable (backward compatibility)
         const envValue = this.configService.get(ENV_MINERU_SERVER_TYPE)?.toLowerCase();
         if (envValue === 'self-hosted') {
             return 'self-hosted';
         }
-        // Automatically determine from URL: if normalized URL matches official address, return 'official'
-        const normalizedOfficialUrl = this.normalizeBaseUrl(DEFAULT_OFFICIAL_BASE_URL);
-        const normalizedBaseUrl = this.normalizeBaseUrl(baseUrl);
-        if (normalizedBaseUrl === normalizedOfficialUrl) {
-            return 'official';
-        }
-        return 'self-hosted';
+        return 'official';
     }
     resolveCredentials(integration) {
         const options = this.readIntegrationOptions(integration);
         const baseUrlFromIntegration = options?.apiUrl;
         const tokenFromIntegration = options?.apiKey;
-        // Read from environment variables (same keys for both official and self-hosted)
-        const baseUrlFromEnv = this.configService.get(ENV_MINERU_API_BASE_URL);
-        const tokenFromEnv = this.configService.get(ENV_MINERU_API_TOKEN);
-        // Determine baseUrl: prefer integration config, then env, then default to official URL
+        const baseUrlEnvKey = this.serverType === 'self-hosted' ? ENV_MINERU_API_BASE_URL : ENV_MINERU_API_BASE_URL;
+        const tokenEnvKey = this.serverType === 'self-hosted' ? ENV_MINERU_API_TOKEN : ENV_MINERU_API_TOKEN;
+        const baseUrlFromEnv = this.configService.get(baseUrlEnvKey);
+        const tokenFromEnv = this.configService.get(tokenEnvKey);
         const baseUrl = baseUrlFromIntegration ||
             baseUrlFromEnv ||
-            DEFAULT_OFFICIAL_BASE_URL;
-        // Determine token: prefer integration config, then env
+            (this.serverType === 'official' ? DEFAULT_OFFICIAL_BASE_URL : undefined);
         const token = tokenFromIntegration || tokenFromEnv;
+        // Validate baseUrl is provided for self-hosted mode
+        if (this.serverType === 'self-hosted' && !baseUrl) {
+            throw new Error('MinerU self-hosted mode requires apiUrl to be configured in integration options or ' +
+                `${ENV_MINERU_API_BASE_URL} environment variable`);
+        }
         return { baseUrl, token };
     }
     readIntegrationOptions(integration) {
@@ -270,11 +243,6 @@ export class MinerUClient {
         if (options.seed)
             body.seed = options.seed;
         try {
-            this.logger.debug('[MinerU] createOfficialTask request', {
-                url,
-                body,
-                hasAuthHeader: Boolean(this.getOfficialHeaders().Authorization),
-            });
             const resp = await axios.post(url, body, { headers: this.getOfficialHeaders() });
             const data = resp.data;
             if (data.code !== 0) {
@@ -288,18 +256,141 @@ export class MinerUClient {
         }
     }
     async createSelfHostedTask(options) {
-        const filePath = this.fileSystem.fullPath(options.filePath);
+        // Validate fileSystem is available for self-hosted mode
+        if (!this.fileSystem) {
+            throw new Error('MinerU self-hosted mode requires fileSystem permission');
+        }
+        // Validate filePath is provided
+        if (!options.filePath) {
+            throw new Error('MinerU self-hosted mode requires filePath to be provided');
+        }
+        // Resolve absolute file path
+        // Log original filePath for debugging
+        const basePath = this.fileSystem ? this.fileSystem.basePath : 'N/A';
+        this.logger.debug(`Resolving file path. Original filePath: ${options.filePath}, basePath: ${basePath}`);
+        // Check if filePath is already an absolute path
+        const isAbsolutePath = isAbsolute(options.filePath);
+        // Also check if it looks like a full path even without leading slash
+        const looksLikeFullPath = !isAbsolutePath && (options.filePath.startsWith('Users/') ||
+            options.filePath.startsWith('home/'));
+        let filePath;
+        if (isAbsolutePath) {
+            // Use absolute path directly
+            filePath = options.filePath;
+            this.logger.debug(`Using absolute path directly: ${filePath}`);
+        }
+        else if (looksLikeFullPath) {
+            // If it looks like a full path but doesn't start with /, add it
+            filePath = options.filePath.startsWith('/') ? options.filePath : '/' + options.filePath;
+            this.logger.debug(`Detected full path pattern, normalized to: ${filePath}`);
+        }
+        else {
+            // Use xpFileSystem.fullPath() to resolve relative path to absolute path
+            filePath = this.fileSystem.fullPath(options.filePath);
+            this.logger.debug(`Resolved relative path using basePath: ${filePath}`);
+        }
+        // Validate file exists and is readable before attempting to parse
+        try {
+            await fs.promises.access(filePath, fs.constants.F_OK | fs.constants.R_OK);
+            const stats = await fs.promises.stat(filePath);
+            this.logger.debug(`Processing file: ${filePath}, size: ${stats.size} bytes`);
+            if (stats.size === 0) {
+                throw new Error(`File is empty: ${filePath}`);
+            }
+        }
+        catch (error) {
+            // If file not found in the resolved path, try to find it in common alternative locations
+            // This handles two scenarios:
+            // 1. StorageFile: files/{tenantId}/filename -> apps/api/public/files/{tenantId}/filename (already tried above)
+            // 2. VolumeClient: folder/filename or filename -> ~/data/folder/filename or ~/data/filename
+            if (error instanceof Error && error.code === 'ENOENT') {
+                const homeDir = process.env.HOME || process.env.USERPROFILE;
+                const originalFilePath = options.filePath;
+                const fileName = basename(originalFilePath);
+                // Build alternative paths for VolumeClient storage
+                const alternativePaths = [];
+                // If original path contains directory separators, try both full path and just filename
+                if (originalFilePath.includes('/') || originalFilePath.includes('\\')) {
+                    // Try full path in ~/data/
+                    alternativePaths.push(pathJoin(homeDir || '', 'data', originalFilePath));
+                    // Try just filename in ~/data/ (for VolumeClient files stored directly in root)
+                    alternativePaths.push(pathJoin(homeDir || '', 'data', fileName));
+                }
+                else {
+                    // If original path is just a filename, try in ~/data/ root
+                    alternativePaths.push(pathJoin(homeDir || '', 'data', originalFilePath));
+                }
+                // Also try in knowledge base specific paths if we can determine knowledgebaseId
+                // Note: We don't have direct access to knowledgebaseId here, but files might be in knowledges subdirectory
+                const resolvedPath = this.fileSystem.fullPath(originalFilePath);
+                if (resolvedPath.includes('apps/api/public')) {
+                    // This looks like a StorageFile path, but file not found
+                    // Try VolumeClient paths as fallback
+                    this.logger.debug(`File not found in StorageFile path, trying VolumeClient paths...`);
+                }
+                let foundPath = null;
+                for (const altPath of alternativePaths) {
+                    try {
+                        await fs.promises.access(altPath, fs.constants.F_OK | fs.constants.R_OK);
+                        const stats = await fs.promises.stat(altPath);
+                        this.logger.debug(`Found file in alternative location: ${altPath}, size: ${stats.size} bytes`);
+                        foundPath = altPath;
+                        if (stats.size === 0) {
+                            throw new Error(`File is empty: ${foundPath}`);
+                        }
+                        break; // File found, exit loop
+                    }
+                    catch (altError) {
+                        // Continue to next alternative path
+                        continue;
+                    }
+                }
+                // If file found in alternative location, use it
+                if (foundPath) {
+                    filePath = foundPath;
+                }
+                else {
+                    // If still not found after trying alternatives, throw original error
+                    const basePath = this.fileSystem ? this.fileSystem.basePath : 'N/A';
+                    this.logger.error(`File not found or not readable. ` +
+                        `Original path: ${originalFilePath}, ` +
+                        `Resolved path: ${filePath}, ` +
+                        `Base path: ${basePath}, ` +
+                        `Tried alternative paths: ${alternativePaths.join(', ')}`, error instanceof Error ? error.stack : error);
+                    throw new Error(`File not found or not readable: ${filePath}. ` +
+                        `Original path: ${originalFilePath}, ` +
+                        `Base path: ${basePath}. ` +
+                        `Tried alternative locations: ${alternativePaths.join(', ')}`);
+                }
+            }
+            else if (error instanceof Error && error.message.includes('empty')) {
+                this.logger.error(`File is empty: ${filePath}`);
+                throw error;
+            }
+            else {
+                // Re-throw other errors
+                throw error;
+            }
+        }
         const taskId = randomUUID();
-        const result = await this.invokeSelfHostedParse(filePath, options.fileName, options);
+        const result = await this.invokeSelfHostedParse(filePath, options.fileName || basename(filePath), options);
         this.localTasks.set(taskId, { ...result, sourceUrl: options.url });
         return { taskId };
     }
     async invokeSelfHostedParse(filePath, fileName, options) {
         const parseUrl = this.buildApiUrl('file_parse');
+        this.logger.debug(`Sending parse request to: ${parseUrl}, file: ${fileName}`);
         const form = new FormData();
-        form.append('files', fs.createReadStream(filePath), {
-            filename: fileName,
-        });
+        // Create file read stream (file existence is already validated in createSelfHostedTask)
+        try {
+            form.append('files', fs.createReadStream(filePath), {
+                filename: fileName,
+            });
+        }
+        catch (error) {
+            this.logger.error(`Failed to create read stream for file: ${filePath}`, error instanceof Error ? error.stack : error);
+            throw new Error(`Failed to read file: ${filePath}. ${error instanceof Error ? error.message : String(error)}`);
+        }
         // form.append('files', fileBuffer, { filename: fileName, contentType: contentType || 'application/pdf' });
         form.append('parse_method', options.parseMethod ?? 'auto');
         form.append('return_md', 'true');
@@ -327,11 +418,27 @@ export class MinerUClient {
             return this.invokeSelfHostedParseV1(filePath, fileName, options);
         }
         if (response.status === 400) {
-            throw new BadRequestException(`MinerU self-hosted parse failed: ${response.status} ${getErrorMessage(response.data)}`);
+            const errorMessage = getErrorMessage(response.data);
+            this.logger.error(`MinerU self-hosted parse failed with 400: ${errorMessage}`, JSON.stringify(response.data));
+            throw new BadRequestException(`MinerU self-hosted parse failed: ${response.status} ${errorMessage}`);
         }
         if (response.status !== 200) {
-            console.error(response.data);
-            throw new Error(`MinerU self-hosted parse failed: ${response.status} ${response.statusText}`);
+            const errorMessage = getErrorMessage(response.data) || response.statusText;
+            const errorDetails = typeof response.data === 'object' ? JSON.stringify(response.data) : String(response.data);
+            this.logger.error(`MinerU self-hosted parse failed with ${response.status}: ${errorMessage}`, `Request URL: ${parseUrl}, File: ${fileName}, Details: ${errorDetails}`);
+            // Provide more helpful error message for common issues
+            let userFriendlyMessage = `MinerU self-hosted parse failed: ${response.status} ${response.statusText}`;
+            if (errorMessage) {
+                userFriendlyMessage += `. ${errorMessage}`;
+            }
+            // Check for specific error patterns
+            if (errorMessage && errorMessage.includes('0 active models')) {
+                userFriendlyMessage += ' Please ensure MinerU service has active models configured.';
+            }
+            else if (errorMessage && errorMessage.includes('NoneType')) {
+                userFriendlyMessage += ' This may indicate a configuration issue with the MinerU service.';
+            }
+            throw new Error(userFriendlyMessage);
         }
         return this.normalizeSelfHostedResponse(response.data);
     }
@@ -360,7 +467,9 @@ export class MinerUClient {
                 validateStatus: () => true,
             });
             if (response.status !== 200) {
-                throw new Error(`MinerU self-hosted legacy parse failed: ${response.status} ${response.statusText}`);
+                const errorMessage = getErrorMessage(response.data) || response.statusText;
+                this.logger.error(`MinerU self-hosted legacy parse failed with ${response.status}: ${errorMessage}`, JSON.stringify(response.data));
+                throw new Error(`MinerU self-hosted legacy parse failed: ${response.status} ${response.statusText}. ${errorMessage}`);
             }
             return this.normalizeSelfHostedResponse(response.data);
         }

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

package/dist/lib/mineru.plugin.js

@@ -7,7 +7,6 @@ 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
@@ -42,7 +41,6 @@ MinerUPlugin = MinerUPlugin_1 = __decorate([
             MinerUIntegrationStrategy,
             MinerUTransformerStrategy,
             MinerUResultParserService,
-            MinerUToolsetStrategy,
         ],
         controllers: [
             MinerUController

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 };