@helloxiaohu/plugin-mineru6 0.0.2

package/dist/lib/mineru.tool.js

@@ -0,0 +1,141 @@
+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 { MinerUIntegration } from './types.js';
+/**
+ * Build MinerU PDF parser tool
+ * This tool converts PDF files to markdown format using MinerU service
+ */
+export function buildMinerUTool(configService, resultParser, options, fileSystem, defaults) {
+    return tool(async (input) => {
+        try {
+            const { 
+            // Coze-like parameters (snake_case)
+            doc_url, token, url, server_type, enable_formula, enable_table, is_ocr, language, model_version } = input;
+            // Use defaults from toolset config if not provided in input
+            const finalIsOcr = is_ocr ?? defaults?.isOcr ?? true;
+            const finalEnableFormula = enable_formula ?? defaults?.enableFormula ?? true;
+            const finalEnableTable = enable_table ?? defaults?.enableTable ?? true;
+            const finalLanguage = language ?? defaults?.language ?? 'ch';
+            const finalModelVersion = model_version ?? defaults?.modelVersion ?? 'pipeline';
+            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';
+            const baseUrl = currentState?.['sys']?.['workspace_url'];
+            // Merge toolset credentials with per-call overrides
+            const effectiveOptions = {
+                // Default to the official MinerU v4 API base URL used by MinerUClient
+                apiUrl: url ?? options?.apiUrl ?? 'https://mineru.net/api/v4',
+                apiKey: token ?? options?.apiKey,
+                serverType: (server_type ?? options?.serverType ?? 'official'),
+            };
+            if (effectiveOptions.serverType === 'official' && !effectiveOptions.apiKey) {
+                throw new Error('token (API Token) is required when server_type is "official"');
+            }
+            const integration = {
+                provider: MinerUIntegration,
+                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
+            }
+            // Create MinerU task
+            const { taskId } = await mineruClient.createTask({
+                url: doc_url,
+                fileName: finalFileName,
+                isOcr: finalIsOcr,
+                enableFormula: finalEnableFormula,
+                enableTable: finalEnableTable,
+                language: finalLanguage,
+                modelVersion: finalModelVersion,
+            });
+            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');
+                }
+                parsedResult = await resultParser.parseLocalTask(taskResult, taskId, {
+                    fileUrl: doc_url,
+                    name: finalFileName,
+                    folder: workspacePath,
+                }, 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, {
+                    fileUrl: doc_url,
+                    name: finalFileName,
+                    folder: workspacePath,
+                }, fileSystem);
+            }
+            // 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 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,
+                        });
+                    }
+                }
+            }
+            // Extract markdown content from chunks
+            const markdownContent = parsedResult.chunks
+                ?.map((chunk) => chunk.pageContent)
+                .join('\n\n') || '';
+            return [
+                `PDF processed successfully by MinerU.\n\nTask ID: ${taskId}\n\nMarkdown Content:\n${markdownContent.substring(0, 1000)}${markdownContent.length > 1000 ? '...' : ''}`,
+                {
+                    files: fileArtifacts,
+                    taskId,
+                    metadata: parsedResult.metadata,
+                },
+            ];
+        }
+        catch (error) {
+            throw new Error(`MinerU processing failed: ${getErrorMessage(error)}`);
+        }
+    }, {
+        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.).',
+        schema: z.object({
+            doc_url: z.string().min(1).describe('PDF URL (required)'),
+            token: z.string().optional().nullable().describe('MinerU API token (required when server_type is "official")'),
+            url: z.string().optional().nullable().describe('MinerU API base url (optional, default: https://mineru.net/api/v4)'),
+            server_type: z.enum(['official', 'self-hosted']).optional().nullable().describe('MinerU service type (default: "official")'),
+            enable_formula: z.boolean().optional().nullable().describe('Enable formula recognition (default: true)'),
+            enable_table: z.boolean().optional().nullable().describe('Enable table recognition (default: true)'),
+            is_ocr: z.boolean().optional().nullable().describe('Enable OCR for image-based PDFs (default: true)'),
+            language: z.enum(['en', 'ch']).optional().nullable().describe('Document language: "en" for English, "ch" for Chinese (default: "ch")'),
+            model_version: z.enum(['pipeline', 'vlm']).optional().nullable().describe('Model version: "pipeline" or "vlm" (default: "pipeline")'),
+        }),
+        responseFormat: 'content_and_artifact',
+    });
+}

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

@@ -0,0 +1,51 @@
+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';
+import { MinerUIntegrationOptions } from './types.js';
+/**
+ * Configuration for MinerU Toolset
+ */
+export interface MinerUToolsetConfig {
+    /**
+     * MinerU API options stored in toolset credentials
+     */
+    apiUrl?: string;
+    apiKey?: string;
+    serverType?: MinerUIntegrationOptions['serverType'];
+    fileSystem?: XpFileSystem;
+    configService?: ConfigService;
+    resultParser?: MinerUResultParserService;
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    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;
+    /**
+     * 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
+     */
+    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;AAEvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,yBAAyB,CAAC;IAEzC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,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;IAE7C;;;;;OAKG;gBACS,MAAM,EAAE,mBAAmB;IAKvC;;;;;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;CA0BzF"}

package/dist/lib/mineru.toolset.js

@@ -0,0 +1,52 @@
+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);
+        this.config = config;
+    }
+    /**
+     * 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
+    }
+    /**
+     * Initialize tools for MinerU toolset
+     * Creates the PDF parser tool with necessary dependencies
+     */
+    async initTools() {
+        const { configService, resultParser, apiUrl, apiKey, serverType, fileSystem, isOcr, enableFormula, enableTable, language, modelVersion } = this.config;
+        if (!configService || !resultParser) {
+            throw new Error('ConfigService and MinerUResultParserService are required');
+        }
+        this.tools = [
+            buildMinerUTool(configService, resultParser, {
+                apiUrl,
+                apiKey,
+                serverType: serverType ?? 'official',
+            }, fileSystem, {
+                isOcr,
+                enableFormula,
+                enableTable,
+                language,
+                modelVersion,
+            }),
+        ];
+        return this.tools;
+    }
+}

package/dist/lib/path-meta.d.ts

@@ -0,0 +1,5 @@
+export declare function getModuleMeta(meta?: ImportMeta): {
+    __filename: string;
+    __dirname: string;
+};
+//# sourceMappingURL=path-meta.d.ts.map

package/dist/lib/path-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-meta.d.ts","sourceRoot":"","sources":["../../src/lib/path-meta.ts"],"names":[],"mappings":"AAGA,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,UAAU;;;EAK9C"}

package/dist/lib/path-meta.js

@@ -0,0 +1,8 @@
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+export function getModuleMeta(meta) {
+    const isESM = typeof require === 'undefined';
+    const filename = isESM ? fileURLToPath(meta.url) : __filename;
+    const dir = isESM ? dirname(filename) : __dirname;
+    return { __filename: filename, __dirname: dir };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-parser.service.d.ts","sourceRoot":"","sources":["../../src/lib/result-parser.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EACL,aAAa,EAEb,YAAY,EACb,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EAEL,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,qBACa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8C;IAE/D,YAAY,CAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,UAAU,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"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformer-mineru.strategy.d.ts","sourceRoot":"","sources":["../../src/lib/transformer-mineru.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAG/D,OAAO,EACL,aAAa,EAEb,oBAAoB,EACpB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,sBAAsB,CAAA;AAI7B,OAAO,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"}