@helloxiaohu/plugin-mineru6 0.0.2

package/dist/lib/mineru.client.js

@@ -0,0 +1,456 @@
+import { BadRequestException, Logger } from '@nestjs/common';
+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 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';
+export class MinerUClient {
+    get fileSystem() {
+        return this.permissions?.fileSystem;
+    }
+    constructor(configService, permissions) {
+        this.configService = configService;
+        this.permissions = permissions;
+        this.logger = new Logger(MinerUClient.name);
+        this.localTasks = new Map();
+        const integration = this.permissions?.integration;
+        this.serverType = this.resolveServerType(integration);
+        const { baseUrl, token } = this.resolveCredentials(integration);
+        if (!baseUrl) {
+            throw new Error('MinerU base URL is required');
+        }
+        this.baseUrl = this.normalizeBaseUrl(baseUrl);
+        this.token = token;
+        if (this.serverType === 'official' && !this.token) {
+            throw new Error('MinerU official API requires an access token');
+        }
+    }
+    /**
+     * Create a MinerU extraction task. For self-hosted deployments the file will be uploaded immediately
+     * and the parsed result cached locally, while official deployments follow the async task lifecycle.
+     */
+    async createTask(options) {
+        if (!options.url) {
+            throw new Error('MinerU createTask requires a document URL');
+        }
+        if (this.serverType === 'self-hosted') {
+            return this.createSelfHostedTask(options);
+        }
+        return this.createOfficialTask(options);
+    }
+    /**
+     * Create a batch MinerU extraction task. Only supported for official MinerU deployments.
+     */
+    async createBatchTask(options) {
+        this.ensureOfficial('createBatchTask');
+        const url = this.buildApiUrl('extract', 'task', 'batch');
+        const body = {
+            files: options.files.map((file) => {
+                const entry = { url: file.url };
+                if (file.isOcr !== undefined)
+                    entry.is_ocr = file.isOcr;
+                if (file.dataId)
+                    entry.data_id = file.dataId;
+                if (file.pageRanges)
+                    entry.page_ranges = file.pageRanges;
+                return entry;
+            }),
+        };
+        if (options.enableFormula !== undefined)
+            body.enable_formula = options.enableFormula;
+        if (options.enableTable !== undefined)
+            body.enable_table = options.enableTable;
+        if (options.language)
+            body.language = options.language;
+        if (options.modelVersion)
+            body.model_version = options.modelVersion;
+        if (options.extraFormats)
+            body.extra_formats = options.extraFormats;
+        if (options.callbackUrl)
+            body.callback = options.callbackUrl;
+        if (options.seed)
+            body.seed = options.seed;
+        try {
+            const resp = await axios.post(url, body, { headers: this.getOfficialHeaders() });
+            const data = resp.data;
+            if (data.code !== 0) {
+                throw new Error(`MinerU createBatchTask failed: ${data.msg}`);
+            }
+            return { batchId: data.data.batch_id, fileUrls: data.data.file_urls };
+        }
+        catch (err) {
+            this.logger.error('createBatchTask error', err instanceof Error ? err.stack : err);
+            throw err;
+        }
+    }
+    getSelfHostedTask(taskId) {
+        if (this.serverType !== 'self-hosted') {
+            throw new Error('getSelfHostedTask is only available for self-hosted MinerU deployments');
+        }
+        return this.localTasks.get(taskId);
+    }
+    /**
+     * Query offical task status or results.
+     */
+    async getTaskResult(taskId, options) {
+        const url = this.buildApiUrl('extract', 'task', taskId);
+        const params = {};
+        if (options?.enableFormula !== undefined)
+            params.enable_formula = options.enableFormula;
+        if (options?.enableTable !== undefined)
+            params.enable_table = options.enableTable;
+        if (options?.language)
+            params.language = options.language;
+        try {
+            const resp = await axios.get(url, { headers: this.getOfficialHeaders(), params });
+            const data = resp.data;
+            if (data.code !== 0) {
+                throw new Error(`MinerU getTaskResult failed: ${data.msg}`);
+            }
+            return data.data;
+        }
+        catch (err) {
+            this.logger.error('getTaskResult error', err instanceof Error ? err.stack : err);
+            throw err;
+        }
+    }
+    /**
+     * Query batch task results. Only supported for official MinerU deployments.
+     */
+    async getBatchResult(batchId) {
+        this.ensureOfficial('getBatchResult');
+        const url = this.buildApiUrl('extract-results', 'batch', batchId);
+        try {
+            const resp = await axios.get(url, { headers: this.getOfficialHeaders() });
+            const data = resp.data;
+            if (data.code !== 0) {
+                throw new Error(`MinerU getBatchResult failed: ${data.msg}`);
+            }
+            return data.data;
+        }
+        catch (err) {
+            this.logger.error('getBatchResult error', err instanceof Error ? err.stack : err);
+            throw err;
+        }
+    }
+    /**
+     * Wait for a task to complete and return the result when available.
+     */
+    async waitForTask(taskId, timeoutMs = 5 * 60 * 1000, intervalMs = 5000) {
+        if (this.serverType === 'self-hosted') {
+            throw new Error('waitForTask is not supported for self-hosted MinerU deployments');
+        }
+        const start = Date.now();
+        while (true) {
+            const result = await this.getTaskResult(taskId);
+            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;
+            }
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(`MinerU waitForTask timeout after ${timeoutMs} ms`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    ensureOfficial(feature) {
+        if (this.serverType !== 'official') {
+            throw new Error(`${feature} is only supported for official MinerU deployments`);
+        }
+    }
+    resolveServerType(integration) {
+        const integrationType = this.readIntegrationOptions(integration)?.serverType;
+        if (integrationType === 'self-hosted' || integrationType === 'official') {
+            return integrationType;
+        }
+        const envValue = this.configService.get(ENV_MINERU_SERVER_TYPE)?.toLowerCase();
+        if (envValue === 'self-hosted') {
+            return 'self-hosted';
+        }
+        return 'official';
+    }
+    resolveCredentials(integration) {
+        const options = this.readIntegrationOptions(integration);
+        const baseUrlFromIntegration = options?.apiUrl;
+        const tokenFromIntegration = options?.apiKey;
+        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 ||
+            (this.serverType === 'official' ? DEFAULT_OFFICIAL_BASE_URL : null);
+        const token = tokenFromIntegration || tokenFromEnv;
+        return { baseUrl, token };
+    }
+    readIntegrationOptions(integration) {
+        return integration?.options || undefined;
+    }
+    normalizeBaseUrl(url) {
+        return url.replace(/\/+$/, '');
+    }
+    buildApiUrl(...segments) {
+        const path = segments
+            .filter(Boolean)
+            .map((segment) => segment.replace(/^\/+|\/+$/g, ''))
+            .join('/');
+        return path ? `${this.baseUrl}/${path}` : this.baseUrl;
+    }
+    getOfficialHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.token}`,
+        };
+    }
+    getSelfHostedHeaders() {
+        const headers = {
+            accept: 'application/json',
+        };
+        if (this.token) {
+            headers.Authorization = `Bearer ${this.token}`;
+        }
+        return headers;
+    }
+    async createOfficialTask(options) {
+        const url = this.buildApiUrl('extract', 'task');
+        const body = { url: options.url };
+        if (options.isOcr !== undefined)
+            body.is_ocr = options.isOcr;
+        if (options.enableFormula !== undefined)
+            body.enable_formula = options.enableFormula;
+        if (options.enableTable !== undefined)
+            body.enable_table = options.enableTable;
+        if (options.language)
+            body.language = options.language;
+        if (options.modelVersion)
+            body.model_version = options.modelVersion;
+        if (options.dataId)
+            body.data_id = options.dataId;
+        if (options.pageRanges)
+            body.page_ranges = options.pageRanges;
+        if (options.extraFormats)
+            body.extra_formats = options.extraFormats;
+        if (options.callbackUrl)
+            body.callback = options.callbackUrl;
+        if (options.seed)
+            body.seed = options.seed;
+        try {
+            const resp = await axios.post(url, body, { headers: this.getOfficialHeaders() });
+            const data = resp.data;
+            if (data.code !== 0) {
+                throw new Error(`MinerU createTask failed: ${data.msg}`);
+            }
+            return { taskId: data.data.task_id };
+        }
+        catch (err) {
+            this.logger.error('createTask error', err instanceof Error ? err.stack : err);
+            throw err;
+        }
+    }
+    async createSelfHostedTask(options) {
+        const filePath = this.fileSystem.fullPath(options.filePath);
+        const taskId = randomUUID();
+        const result = await this.invokeSelfHostedParse(filePath, options.fileName, options);
+        this.localTasks.set(taskId, { ...result, sourceUrl: options.url });
+        return { taskId };
+    }
+    async invokeSelfHostedParse(filePath, fileName, options) {
+        const parseUrl = this.buildApiUrl('file_parse');
+        const form = new FormData();
+        form.append('files', fs.createReadStream(filePath), {
+            filename: fileName,
+        });
+        // form.append('files', fileBuffer, { filename: fileName, contentType: contentType || 'application/pdf' });
+        form.append('parse_method', options.parseMethod ?? 'auto');
+        form.append('return_md', 'true');
+        form.append('return_model_output', 'false');
+        form.append('return_content_list', 'true');
+        // form.append('lang_list', JSON.stringify(this.buildLanguageList(options.language)));
+        form.append('return_images', 'true');
+        form.append('backend', options.backend ?? options.modelVersion ?? 'pipeline');
+        form.append('formula_enable', this.booleanToString(options.enableFormula ?? true));
+        form.append('table_enable', this.booleanToString(options.enableTable ?? true));
+        form.append('return_middle_json', this.booleanToString(options.returnMiddleJson ?? false));
+        if (options.serverUrl) {
+            form.append('server_url', options.serverUrl);
+        }
+        const headers = {
+            ...this.getSelfHostedHeaders(),
+            ...form.getHeaders(),
+        };
+        const response = await axios.post(parseUrl, form, {
+            headers,
+            maxBodyLength: Infinity,
+            validateStatus: () => true,
+        });
+        if (this.isSelfHostedApiV1(response)) {
+            return this.invokeSelfHostedParseV1(filePath, fileName, options);
+        }
+        if (response.status === 400) {
+            throw new BadRequestException(`MinerU self-hosted parse failed: ${response.status} ${getErrorMessage(response.data)}`);
+        }
+        if (response.status !== 200) {
+            console.error(response.data);
+            throw new Error(`MinerU self-hosted parse failed: ${response.status} ${response.statusText}`);
+        }
+        return this.normalizeSelfHostedResponse(response.data);
+    }
+    async invokeSelfHostedParseV1(filePath, fileName, options) {
+        const parseUrl = this.buildApiUrl('file_parse');
+        const form = new FormData();
+        form.append('files', fs.createReadStream(filePath), {
+            filename: fileName,
+        });
+        const params = {
+            parse_method: options.parseMethod ?? 'auto',
+            return_layout: false,
+            return_info: false,
+            return_content_list: true,
+            return_images: true,
+        };
+        const headers = {
+            ...this.getSelfHostedHeaders(),
+            ...form.getHeaders(),
+        };
+        try {
+            const response = await axios.post(parseUrl, form, {
+                headers,
+                params,
+                maxBodyLength: Infinity,
+                validateStatus: () => true,
+            });
+            if (response.status !== 200) {
+                throw new Error(`MinerU self-hosted legacy parse failed: ${response.status} ${response.statusText}`);
+            }
+            return this.normalizeSelfHostedResponse(response.data);
+        }
+        catch (error) {
+            this.logger.error('invokeSelfHostedParseV1 error', error instanceof Error ? error.stack : error);
+            throw error;
+        }
+    }
+    isSelfHostedApiV1(response) {
+        if (response.status !== 422) {
+            return false;
+        }
+        const detail = response.data?.detail;
+        if (!Array.isArray(detail)) {
+            return false;
+        }
+        return detail.some((item) => {
+            const loc = item?.loc;
+            return item?.type === 'missing' && Array.isArray(loc) && loc[0] === 'body' && loc[1] === 'file';
+        });
+    }
+    normalizeSelfHostedResponse(payload) {
+        if (!payload) {
+            throw new Error('MinerU self-hosted parse returned empty payload');
+        }
+        if (payload.results && typeof payload.results === 'object') {
+            const [firstKey] = Object.keys(payload.results);
+            if (firstKey) {
+                return this.normalizeSelfHostedFileResult(payload.results[firstKey], firstKey);
+            }
+        }
+        return this.normalizeSelfHostedFileResult(payload);
+    }
+    normalizeSelfHostedFileResult(result, fileName) {
+        const mdContent = result?.md_content ?? '';
+        const contentList = this.parseJsonSafe(result?.content_list);
+        const images = this.normalizeImageMap(result?.images);
+        return {
+            mdContent,
+            contentList,
+            images,
+            raw: result,
+            fileName,
+        };
+    }
+    normalizeImageMap(map) {
+        if (!map) {
+            return [];
+        }
+        return Object.entries(map).map(([name, dataUrl]) => ({ name, dataUrl }));
+    }
+    parseJsonSafe(value) {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`Failed to parse MinerU content_list JSON: ${message}`);
+            return value;
+        }
+    }
+    buildLanguageList(language) {
+        if (!language || language === 'auto') {
+            return ['zh'];
+        }
+        return [language];
+    }
+    booleanToString(value) {
+        return value ? 'true' : 'false';
+    }
+    async downloadFile(url) {
+        try {
+            const response = await axios.get(url, { responseType: 'arraybuffer' });
+            const buffer = Buffer.from(response.data);
+            const contentType = response.headers['content-type'];
+            const contentDisposition = response.headers['content-disposition'];
+            return {
+                buffer,
+                fileName: this.extractFileName(url, contentDisposition),
+                contentType,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to download file for MinerU from ${url}`, error instanceof Error ? error.stack : error);
+            throw error;
+        }
+    }
+    extractFileName(sourceUrl, contentDisposition) {
+        const dispositionMatch = /filename\*=UTF-8''([^;]+)|filename="?([^";]+)"?/i.exec(contentDisposition || '');
+        if (dispositionMatch) {
+            const encodedName = dispositionMatch[1] || dispositionMatch[2];
+            if (encodedName) {
+                try {
+                    return decodeURIComponent(encodedName);
+                }
+                catch {
+                    return encodedName;
+                }
+            }
+        }
+        try {
+            const pathname = new URL(sourceUrl).pathname;
+            const name = basename(pathname);
+            if (name) {
+                return name;
+            }
+        }
+        catch {
+            // Ignore URL parsing errors and fallback to default
+        }
+        return `mineru-${Date.now()}.pdf`;
+    }
+    getSelfHostedOpenApiSpec() {
+        const url = this.buildApiUrl('openapi.json');
+        return axios.get(url, { headers: this.getSelfHostedHeaders() });
+    }
+    async validateOfficialApiToken() {
+        const url = this.buildApiUrl('/extract/task/xxxxxxx');
+        const response = await axios.get(url, { headers: this.getOfficialHeaders() });
+        if (response.status !== 200) {
+            throw new BadRequestException(`MinerU official API token validation failed: ${getErrorMessage(response.data)}`);
+        }
+        if (response.data.code !== -60012) {
+            throw new BadRequestException('MinerU official Base URL or API token is invalid');
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type IIntegration, LanguagesEnum } from '@metad/contracts';
+export declare class MinerUController {
+    private readonly minerUIntegrationStrategy;
+    connect(integration: IIntegration, languageCode: LanguagesEnum): Promise<{
+        success: boolean;
+    }>;
+    private formatErrorMessage;
+}
+//# sourceMappingURL=mineru.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mineru.controller.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAKnE,qBACa,gBAAgB;IAG5B,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA2B;IAI/D,OAAO,CAAS,WAAW,EAAE,YAAY,EAAc,YAAY,EAAE,aAAa;;;IAWxF,OAAO,CAAC,kBAAkB;CAW1B"}

package/dist/lib/mineru.controller.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { LanguagesEnum } from '@metad/contracts';
+import { BadRequestException, Body, Controller, Inject, Post } from '@nestjs/common';
+import { I18nLang } from 'nestjs-i18n';
+import { MinerUIntegrationStrategy } from './integration.strategy.js';
+let MinerUController = class MinerUController {
+    async connect(integration, languageCode) {
+        try {
+            await this.minerUIntegrationStrategy.validateConfig(integration.options);
+        }
+        catch (error) {
+            console.error(error);
+            throw new BadRequestException(this.formatErrorMessage(languageCode, error));
+        }
+        return { success: true };
+    }
+    formatErrorMessage(languageCode, error) {
+        const baseMessage = {
+            [LanguagesEnum.English]: 'Failed to connect to MinerU. Please verify your API configuration.',
+            [LanguagesEnum.SimplifiedChinese]: '无法连接到 MinerU。请检查您的 API 配置。',
+        }[languageCode] ?? 'Failed to connect to MinerU.';
+        const detail = error instanceof Error ? error.message : String(error);
+        return [baseMessage, detail].filter(Boolean).join(' ');
+    }
+};
+__decorate([
+    Inject(MinerUIntegrationStrategy),
+    __metadata("design:type", MinerUIntegrationStrategy)
+], MinerUController.prototype, "minerUIntegrationStrategy", void 0);
+__decorate([
+    Post('test'),
+    __param(0, Body()),
+    __param(1, I18nLang()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], MinerUController.prototype, "connect", null);
+MinerUController = __decorate([
+    Controller('mineru')
+], MinerUController);
+export { MinerUController };

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

@@ -0,0 +1,13 @@
+import { IOnPluginBootstrap, IOnPluginDestroy } from '@xpert-ai/plugin-sdk';
+export declare class MinerUPlugin implements IOnPluginBootstrap, IOnPluginDestroy {
+    private logEnabled;
+    /**
+     * Called when the plugin is being initialized.
+     */
+    onPluginBootstrap(): void | Promise<void>;
+    /**
+     * Called when the plugin is being destroyed.
+     */
+    onPluginDestroy(): void | Promise<void>;
+}
+//# sourceMappingURL=mineru.plugin.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/mineru.plugin.js

@@ -0,0 +1,52 @@
+var MinerUPlugin_1;
+import { __decorate } from "tslib";
+import chalk from 'chalk';
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import { ConfigModule } from '@nestjs/config';
+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
+        this.logEnabled = true;
+    }
+    /**
+     * Called when the plugin is being initialized.
+     */
+    onPluginBootstrap() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MinerUPlugin_1.name} is being bootstrapped...`));
+        }
+    }
+    /**
+     * Called when the plugin is being destroyed.
+     */
+    onPluginDestroy() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MinerUPlugin_1.name} is being destroyed...`));
+        }
+    }
+};
+MinerUPlugin = MinerUPlugin_1 = __decorate([
+    XpertServerPlugin({
+        /**
+         * An array of modules that will be imported and registered with the plugin.
+         */
+        imports: [
+            ConfigModule,
+        ],
+        providers: [
+            MinerUIntegrationStrategy,
+            MinerUTransformerStrategy,
+            MinerUResultParserService,
+            MinerUToolsetStrategy,
+        ],
+        controllers: [
+            MinerUController
+        ]
+    })
+], MinerUPlugin);
+export { MinerUPlugin };

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

@@ -0,0 +1,75 @@
+import { XpFileSystem } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+import { ConfigService } from '@nestjs/config';
+import { MinerUResultParserService } from './result-parser.service.js';
+import { MinerUIntegrationOptions } from './types.js';
+/**
+ * Default parsing settings for MinerU tool
+ */
+export interface MinerUToolDefaults {
+    isOcr?: boolean;
+    enableFormula?: boolean;
+    enableTable?: boolean;
+    language?: 'en' | 'ch';
+    modelVersion?: 'pipeline' | 'vlm';
+}
+/**
+ * Build MinerU PDF parser tool
+ * This tool converts PDF files to markdown format using MinerU service
+ */
+export declare function buildMinerUTool(configService: ConfigService, resultParser: MinerUResultParserService, options?: MinerUIntegrationOptions, fileSystem?: XpFileSystem, defaults?: MinerUToolDefaults): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    doc_url: z.ZodString;
+    token: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    url: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    server_type: z.ZodNullable<z.ZodOptional<z.ZodEnum<["official", "self-hosted"]>>>;
+    enable_formula: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    enable_table: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    is_ocr: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    language: z.ZodNullable<z.ZodOptional<z.ZodEnum<["en", "ch"]>>>;
+    model_version: z.ZodNullable<z.ZodOptional<z.ZodEnum<["pipeline", "vlm"]>>>;
+}, "strip", z.ZodTypeAny, {
+    token?: string;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: "en" | "ch";
+    model_version?: "vlm" | "pipeline";
+    url?: string;
+    is_ocr?: boolean;
+    doc_url?: string;
+    server_type?: "official" | "self-hosted";
+}, {
+    token?: string;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: "en" | "ch";
+    model_version?: "vlm" | "pipeline";
+    url?: string;
+    is_ocr?: boolean;
+    doc_url?: string;
+    server_type?: "official" | "self-hosted";
+}>, {
+    token?: string;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: "en" | "ch";
+    model_version?: "vlm" | "pipeline";
+    url?: string;
+    is_ocr?: boolean;
+    doc_url?: string;
+    server_type?: "official" | "self-hosted";
+}, {
+    token?: string;
+    enable_formula?: boolean;
+    enable_table?: boolean;
+    language?: "en" | "ch";
+    model_version?: "vlm" | "pipeline";
+    url?: string;
+    is_ocr?: boolean;
+    doc_url?: string;
+    server_type?: "official" | "self-hosted";
+}, (string | {
+    files: any[];
+    taskId: string;
+    metadata: any;
+})[]>;
+//# sourceMappingURL=mineru.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mineru.tool.d.ts","sourceRoot":"","sources":["../../src/lib/mineru.tool.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,OAAO,EAAqB,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,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,wBAAgB,eAAe,CAC7B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,yBAAyB,EACvC,OAAO,CAAC,EAAE,wBAAwB,EAClC,UAAU,CAAC,EAAE,YAAY,EACzB,QAAQ,CAAC,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2K9B"}