@noedgeai-org/doc2x-mcp 0.1.3-dev.2.2 → 0.1.3-dev.4.1

package/dist/mcp/registerImageTools.js

@@ -0,0 +1,86 @@
+import { isRetryableError } from '#errors';
+import { parseImageLayoutStatus, parseImageLayoutSubmit, parseImageLayoutSync, parseImageLayoutWaitTextByUid, } from '#doc2x/image';
+import { asJsonResult, asTextResult } from '#mcp/results';
+import { deleteUidCache, fileSig, getSubmittedUidFromCache, imagePathForWaitSchema, imagePathSchema, missingEitherFieldError, parseImageUidSchema, positiveIntMsSchema, setFailedUidCache, setSubmittedUidCache, withToolErrorHandling, } from '#mcp/registerToolsShared';
+export function registerImageTools(server, ctx) {
+    server.registerTool('doc2x_parse_image_layout_sync', {
+        description: 'Parse an image layout synchronously and return the raw Doc2x result JSON (including convert_zip when present).',
+        inputSchema: {
+            image_path: imagePathSchema,
+        },
+    }, withToolErrorHandling(async ({ image_path }) => asJsonResult(await parseImageLayoutSync(image_path))));
+    server.registerTool('doc2x_parse_image_layout_submit', {
+        description: 'Create an async image-layout parse task and return {uid}. After this, call doc2x_parse_image_layout_wait_text (with uid) or doc2x_parse_image_layout_status.',
+        inputSchema: {
+            image_path: imagePathSchema,
+        },
+    }, withToolErrorHandling(async ({ image_path }) => {
+        const sig = await fileSig(image_path);
+        const res = await parseImageLayoutSubmit(image_path);
+        setSubmittedUidCache(ctx, { kind: 'image', key: sig.absPath, sig, uid: res.uid });
+        return asJsonResult(res);
+    }));
+    server.registerTool('doc2x_parse_image_layout_status', {
+        description: 'Get status/result for an existing async image-layout parse task by uid.',
+        inputSchema: {
+            uid: parseImageUidSchema,
+        },
+    }, withToolErrorHandling(async ({ uid }) => asJsonResult(await parseImageLayoutStatus(uid))));
+    server.registerTool('doc2x_parse_image_layout_wait_text', {
+        description: 'Wait for an image-layout parse task until success, returning first page markdown. Prefer passing uid (no re-submit). If only image_path is provided, it will (a) reuse an in-process cached uid if available, otherwise (b) submit a new async task then wait.',
+        inputSchema: {
+            uid: parseImageUidSchema.optional(),
+            image_path: imagePathForWaitSchema.optional(),
+            poll_interval_ms: positiveIntMsSchema.optional(),
+            max_wait_ms: positiveIntMsSchema.optional(),
+        },
+    }, withToolErrorHandling(async (args) => {
+        const uid = String(args.uid || '').trim();
+        if (uid) {
+            const out = await parseImageLayoutWaitTextByUid({
+                uid,
+                poll_interval_ms: args.poll_interval_ms,
+                max_wait_ms: args.max_wait_ms,
+            });
+            return asTextResult(out.text);
+        }
+        const imagePath = String(args.image_path || '').trim();
+        if (!imagePath)
+            throw missingEitherFieldError('uid', 'image_path');
+        const sig = await fileSig(imagePath);
+        const resolvedUid = getSubmittedUidFromCache(ctx, { kind: 'image', key: sig.absPath, sig });
+        const finalUid = resolvedUid || (await parseImageLayoutSubmit(imagePath)).uid;
+        setSubmittedUidCache(ctx, { kind: 'image', key: sig.absPath, sig, uid: finalUid });
+        const waitByUid = async (uid) => parseImageLayoutWaitTextByUid({
+            uid,
+            poll_interval_ms: args.poll_interval_ms,
+            max_wait_ms: args.max_wait_ms,
+        });
+        const markFailed = (uid) => setFailedUidCache(ctx, { kind: 'image', key: sig.absPath, sig, uid });
+        try {
+            const out = await waitByUid(finalUid);
+            return asTextResult(out.text);
+        }
+        catch (e) {
+            if (!resolvedUid) {
+                markFailed(finalUid);
+                throw e;
+            }
+            deleteUidCache(ctx, { kind: 'image', key: sig.absPath });
+            if (!isRetryableError(e)) {
+                markFailed(finalUid);
+                throw e;
+            }
+            const retryUid = (await parseImageLayoutSubmit(imagePath)).uid;
+            setSubmittedUidCache(ctx, { kind: 'image', key: sig.absPath, sig, uid: retryUid });
+            try {
+                const out = await waitByUid(retryUid);
+                return asTextResult(out.text);
+            }
+            catch (retryErr) {
+                markFailed(retryUid);
+                throw retryErr;
+            }
+        }
+    }));
+}

package/dist/mcp/registerMiscTools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerMiscTools(server: McpServer): void;

package/dist/mcp/registerMiscTools.js

@@ -0,0 +1,36 @@
+import { CONFIG, RESOLVED_KEY, parseDownloadUrlAllowlist } from '#config';
+import { downloadUrlToFile } from '#doc2x/download';
+import { materializeConvertZip } from '#doc2x/materialize';
+import { asJsonResult } from '#mcp/results';
+import { convertZipBase64Schema, doc2xDownloadUrlSchema, outputDirSchema, outputPathSchema, withToolErrorHandling, } from '#mcp/registerToolsShared';
+export function registerMiscTools(server) {
+    server.registerTool('doc2x_download_url_to_file', {
+        description: 'Download a Doc2x-provided URL (e.g. from doc2x_convert_export_result) to a local file path.',
+        inputSchema: {
+            url: doc2xDownloadUrlSchema,
+            output_path: outputPathSchema,
+        },
+    }, withToolErrorHandling(async (args) => asJsonResult(await downloadUrlToFile(args))));
+    server.registerTool('doc2x_materialize_convert_zip', {
+        description: 'Materialize convert_zip (base64) into output_dir. Best-effort: tries system unzip first; otherwise writes the zip file.',
+        inputSchema: { convert_zip_base64: convertZipBase64Schema, output_dir: outputDirSchema },
+    }, withToolErrorHandling(async (args) => asJsonResult(await materializeConvertZip({
+        convert_zip_base64: args.convert_zip_base64,
+        output_dir: args.output_dir,
+    }))));
+    server.registerTool('doc2x_debug_config', {
+        description: 'Debug helper: return resolved config and API key source for troubleshooting.',
+        inputSchema: {},
+    }, withToolErrorHandling(async () => asJsonResult({
+        baseUrl: CONFIG.baseUrl,
+        apiKeySource: RESOLVED_KEY.source,
+        apiKeyLen: CONFIG.apiKey.length,
+        apiKeyPrefix: CONFIG.apiKey ? CONFIG.apiKey.slice(0, 6) : '',
+        pollIntervalMs: CONFIG.pollIntervalMs,
+        httpTimeoutMs: CONFIG.httpTimeoutMs,
+        maxWaitMs: CONFIG.maxWaitMs,
+        parsePdfMaxOutputChars: CONFIG.parsePdfMaxOutputChars,
+        parsePdfMaxOutputPages: CONFIG.parsePdfMaxOutputPages,
+        downloadUrlAllowlist: parseDownloadUrlAllowlist(),
+    })));
+}

package/dist/mcp/registerPdfTools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type RegisterToolsContext } from '#mcp/registerToolsShared';
+export declare function registerPdfTools(server: McpServer, ctx: RegisterToolsContext): void;

package/dist/mcp/registerPdfTools.js

@@ -0,0 +1,123 @@
+import { CONFIG } from '#config';
+import { isRetryableError } from '#errors';
+import { parsePdfStatus, parsePdfSubmit, parsePdfWaitTextByUid, } from '#doc2x/pdf';
+import { asJsonResult, asTextResult } from '#mcp/results';
+import { deleteUidCache, fileSig, getSubmittedUidFromCache, joinWithSchema, makePdfUidCacheKey, missingEitherFieldError, nonNegativeIntSchema, parsePdfModelSchema, parsePdfUidSchema, pdfPathForWaitSchema, pdfPathSchema, positiveIntMsSchema, setFailedUidCache, setSubmittedUidCache, withToolErrorHandling, } from '#mcp/registerToolsShared';
+export function registerPdfTools(server, ctx) {
+    server.registerTool('doc2x_parse_pdf_submit', {
+        description: 'Create a Doc2x PDF parse task for a local file and return {uid}. Prefer calling doc2x_parse_pdf_status to monitor progress/result; only call doc2x_parse_pdf_wait_text if the user explicitly asks to wait/return merged text.',
+        inputSchema: {
+            pdf_path: pdfPathSchema,
+            model: parsePdfModelSchema.describe("Optional parse model. Use 'v3-2026' to try the latest model. Omit this field to use default v2."),
+        },
+    }, withToolErrorHandling(async ({ pdf_path, model }) => {
+        const sig = await fileSig(pdf_path);
+        const res = await parsePdfSubmit(pdf_path, { model });
+        setSubmittedUidCache(ctx, {
+            kind: 'pdf',
+            key: makePdfUidCacheKey(sig.absPath, model),
+            sig,
+            uid: res.uid,
+        });
+        return asJsonResult(res);
+    }));
+    server.registerTool('doc2x_parse_pdf_status', {
+        description: 'Query parse task status by uid. Returns {status, progress, detail}. status is one of processing/failed/success; progress is an integer 0..100; detail is populated only when status=failed. Fetch parsed content via doc2x_convert_export_*.',
+        inputSchema: {
+            uid: parsePdfUidSchema,
+        },
+    }, withToolErrorHandling(async (args) => {
+        const st = await parsePdfStatus(args.uid);
+        return asJsonResult({ status: st.status, progress: st.progress, detail: st.detail });
+    }));
+    server.registerTool('doc2x_parse_pdf_wait_text', {
+        description: 'Wait for a PDF parse task until success and return merged text. Prefer passing uid (no re-submit). If only pdf_path is provided, it will (a) reuse an in-process cached uid if available, otherwise (b) submit a new task then wait.',
+        inputSchema: {
+            uid: parsePdfUidSchema.optional(),
+            pdf_path: pdfPathForWaitSchema.optional(),
+            poll_interval_ms: positiveIntMsSchema.optional(),
+            max_wait_ms: positiveIntMsSchema.optional(),
+            join_with: joinWithSchema,
+            max_output_chars: nonNegativeIntSchema
+                .optional()
+                .describe('Max characters of returned text (0 = unlimited). Useful to avoid LLM context overflow. Default can be set via env DOC2X_PARSE_PDF_MAX_OUTPUT_CHARS.'),
+            max_output_pages: nonNegativeIntSchema
+                .optional()
+                .describe('Max pages to merge into returned text (0 = unlimited). Default can be set via env DOC2X_PARSE_PDF_MAX_OUTPUT_PAGES.'),
+            model: parsePdfModelSchema
+                .describe("Optional parse model used only when submitting from pdf_path. Use 'v3-2026' to try latest model. Omit this field to use default v2."),
+        },
+    }, withToolErrorHandling(async (args) => {
+        const maxOutputChars = args.max_output_chars ?? CONFIG.parsePdfMaxOutputChars;
+        const maxOutputPages = args.max_output_pages ?? CONFIG.parsePdfMaxOutputPages;
+        const appendNotice = (text, notice) => {
+            if (maxOutputChars <= 0)
+                return text + notice;
+            if (text.length + notice.length <= maxOutputChars)
+                return text + notice;
+            const keep = Math.min(Math.max(maxOutputChars - notice.length, 0), maxOutputChars);
+            if (keep <= 0)
+                return notice.slice(0, maxOutputChars);
+            return text.slice(0, keep) + notice;
+        };
+        const truncationNotice = (o) => `\n\n---\n[doc2x-mcp] Output truncated (pages ${o.returnedPages}/${o.totalPages}, uid=${o.uid}). Fetch full markdown via doc2x_convert_export_* (to=md).\n`;
+        const uid = String(args.uid || '').trim();
+        if (uid) {
+            const out = await parsePdfWaitTextByUid({
+                uid,
+                poll_interval_ms: args.poll_interval_ms,
+                max_wait_ms: args.max_wait_ms,
+                join_with: args.join_with,
+                max_output_chars: maxOutputChars,
+                max_output_pages: maxOutputPages,
+            });
+            const notice = out.truncated ? truncationNotice(out) : '';
+            return asTextResult(notice ? appendNotice(out.text, notice) : out.text);
+        }
+        const pdfPath = String(args.pdf_path || '').trim();
+        if (!pdfPath)
+            throw missingEitherFieldError('uid', 'pdf_path');
+        const sig = await fileSig(pdfPath);
+        const model = args.model;
+        const cacheKey = makePdfUidCacheKey(sig.absPath, model);
+        const resolvedUid = getSubmittedUidFromCache(ctx, { kind: 'pdf', key: cacheKey, sig });
+        const finalUid = resolvedUid || (await parsePdfSubmit(pdfPath, { model })).uid;
+        setSubmittedUidCache(ctx, { kind: 'pdf', key: cacheKey, sig, uid: finalUid });
+        const waitByUid = async (uid) => parsePdfWaitTextByUid({
+            uid,
+            poll_interval_ms: args.poll_interval_ms,
+            max_wait_ms: args.max_wait_ms,
+            join_with: args.join_with,
+            max_output_chars: maxOutputChars,
+            max_output_pages: maxOutputPages,
+        });
+        const markFailed = (uid) => setFailedUidCache(ctx, { kind: 'pdf', key: cacheKey, sig, uid });
+        try {
+            const out = await waitByUid(finalUid);
+            const notice = out.truncated ? truncationNotice(out) : '';
+            return asTextResult(notice ? appendNotice(out.text, notice) : out.text);
+        }
+        catch (e) {
+            if (!resolvedUid) {
+                markFailed(finalUid);
+                throw e;
+            }
+            deleteUidCache(ctx, { kind: 'pdf', key: cacheKey });
+            if (!isRetryableError(e)) {
+                markFailed(finalUid);
+                throw e;
+            }
+            const retryUid = (await parsePdfSubmit(pdfPath, { model })).uid;
+            setSubmittedUidCache(ctx, { kind: 'pdf', key: cacheKey, sig, uid: retryUid });
+            try {
+                const out = await waitByUid(retryUid);
+                const notice = out.truncated ? truncationNotice(out) : '';
+                return asTextResult(notice ? appendNotice(out.text, notice) : out.text);
+            }
+            catch (retryErr) {
+                markFailed(retryUid);
+                throw retryErr;
+            }
+        }
+    }));
+}

package/dist/mcp/registerTools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTools(server: McpServer): void;