@sylphx/pdf-reader-mcp 1.1.0 → 1.2.0

package/dist/handlers/readPdf.js

@@ -1,7 +1,7 @@
 // PDF reading handler - orchestrates PDF processing workflow
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { buildWarnings, extractImages, extractMetadataAndPageCount, extractPageTexts, } from '../pdf/extractor.js';
+import { buildWarnings, extractMetadataAndPageCount, extractPageContent, } from '../pdf/extractor.js';
 import { loadPdfDocument } from '../pdf/loader.js';
 import { determinePagesToProcess, getTargetPages } from '../pdf/parser.js';
 import { readPdfArgsSchema } from '../schemas/readPdf.js';
@@ -28,9 +28,23 @@ const processSingleSource = async (source, options) => {
         if (warnings.length > 0) {
             output.warnings = warnings;
         }
-        // Extract text if needed
+        // Extract content with ordering preserved
         if (pagesToProcess.length > 0) {
-            const extractedPageTexts = await extractPageTexts(pdfDocument, pagesToProcess, sourceDescription);
+            // Use new extractPageContent to preserve Y-coordinate ordering
+            const pageContents = await Promise.all(pagesToProcess.map((pageNum) => extractPageContent(pdfDocument, pageNum, options.includeImages, sourceDescription)));
+            // Store page contents for ordered retrieval
+            output.page_contents = pageContents.map((items, idx) => ({
+                page: pagesToProcess[idx],
+                items,
+            }));
+            // For backward compatibility, also provide text-only outputs
+            const extractedPageTexts = pageContents.map((items, idx) => ({
+                page: pagesToProcess[idx],
+                text: items
+                    .filter((item) => item.type === 'text')
+                    .map((item) => item.textContent)
+                    .join(''),
+            }));
             if (targetPages) {
                 // Specific pages requested
                 output.page_texts = extractedPageTexts;
@@ -39,12 +53,15 @@ const processSingleSource = async (source, options) => {
                 // Full text requested
                 output.full_text = extractedPageTexts.map((p) => p.text).join('\n\n');
             }
-        }
-        // Extract images if needed
-        if (options.includeImages && pagesToProcess.length > 0) {
-            const extractedImages = await extractImages(pdfDocument, pagesToProcess);
-            if (extractedImages.length > 0) {
-                output.images = extractedImages;
+            // Extract image metadata for JSON response
+            if (options.includeImages) {
+                const extractedImages = pageContents
+                    .flatMap((items) => items.filter((item) => item.type === 'image' && item.imageData))
+                    .map((item) => item.imageData)
+                    .filter((img) => img !== undefined);
+                if (extractedImages.length > 0) {
+                    output.images = extractedImages;
+                }
             }
         }
         individualResult = { ...individualResult, data: output, success: true };
@@ -91,19 +108,22 @@ export const handleReadPdfFunc = async (args) => {
     })));
     // Build content parts - start with structured JSON for backward compatibility
     const content = [];
-    // Strip image data from JSON to keep it manageable
+    // Strip image data and page_contents from JSON to keep it manageable
     const resultsForJson = results.map((result) => {
-        if (result.data?.images) {
-            const { images, ...dataWithoutImages } = result.data;
+        if (result.data) {
+            const { images, page_contents, ...dataWithoutBinaryContent } = result.data;
             // Include image count and metadata in JSON, but not the base64 data
-            const imageInfo = images.map((img) => ({
-                page: img.page,
-                index: img.index,
-                width: img.width,
-                height: img.height,
-                format: img.format,
-            }));
-            return { ...result, data: { ...dataWithoutImages, image_info: imageInfo } };
+            if (images) {
+                const imageInfo = images.map((img) => ({
+                    page: img.page,
+                    index: img.index,
+                    width: img.width,
+                    height: img.height,
+                    format: img.format,
+                }));
+                return { ...result, data: { ...dataWithoutBinaryContent, image_info: imageInfo } };
+            }
+            return { ...result, data: dataWithoutBinaryContent };
         }
         return result;
     });
@@ -112,40 +132,27 @@ export const handleReadPdfFunc = async (args) => {
         type: 'text',
         text: JSON.stringify({ results: resultsForJson }, null, 2),
     });
-    // Add page content in order: text then images for each page
-    if (include_images) {
-        for (const result of results) {
-            if (!result.success || !result.data)
-                continue;
-            // Handle page_texts (specific pages requested)
-            if (result.data.page_texts) {
-                for (const pageText of result.data.page_texts) {
-                    // Add images for this page (if any) right after page text
-                    if (result.data.images) {
-                        const pageImages = result.data.images.filter((img) => img.page === pageText.page);
-                        for (const image of pageImages) {
-                            content.push({
-                                type: 'image',
-                                data: image.data,
-                                mimeType: image.format === 'rgba' ? 'image/png' : 'image/jpeg',
-                            });
-                        }
-                    }
+    // Add page content in exact Y-coordinate order
+    for (const result of results) {
+        if (!result.success || !result.data?.page_contents)
+            continue;
+        // Process each page's content items in order
+        for (const pageContent of result.data.page_contents) {
+            for (const item of pageContent.items) {
+                if (item.type === 'text' && item.textContent) {
+                    // Add text content part
+                    content.push({
+                        type: 'text',
+                        text: item.textContent,
+                    });
                 }
-            }
-            // Handle full_text mode - add all images by page order
-            if (result.data.full_text && result.data.images) {
-                // Group images by page and add in order
-                const pageNumbers = [...new Set(result.data.images.map((img) => img.page))].sort((a, b) => a - b);
-                for (const pageNum of pageNumbers) {
-                    const pageImages = result.data.images.filter((img) => img.page === pageNum);
-                    for (const image of pageImages) {
-                        content.push({
-                            type: 'image',
-                            data: image.data,
-                            mimeType: image.format === 'rgba' ? 'image/png' : 'image/jpeg',
-                        });
-                    }
+                else if (item.type === 'image' && item.imageData) {
+                    // Add image content part
+                    content.push({
+                        type: 'image',
+                        data: item.imageData.data,
+                        mimeType: item.imageData.format === 'rgba' ? 'image/png' : 'image/jpeg',
+                    });
                 }
             }
         }

package/dist/index.js

@@ -11,7 +11,7 @@ import { allToolDefinitions } from './handlers/index.js';
 // --- Server Setup ---
 const server = new Server({
     name: 'pdf-reader-mcp',
-    version: '1.1.0',
+    version: '1.2.0',
     description: 'MCP Server for reading PDF files and extracting text, metadata, images, and page information.',
 }, {
     capabilities: { tools: {} },

package/dist/pdf/extractor.js

@@ -151,3 +151,115 @@ export const buildWarnings = (invalidPages, totalPages) => {
         `Requested page numbers ${invalidPages.join(', ')} exceed total pages (${String(totalPages)}).`,
     ];
 };
+/**
+ * Extract all content (text and images) from a single page with Y-coordinate ordering
+ */
+export const extractPageContent = async (pdfDocument, pageNum, includeImages, sourceDescription) => {
+    const contentItems = [];
+    try {
+        const page = await pdfDocument.getPage(pageNum);
+        // Extract text content with Y-coordinates
+        const textContent = await page.getTextContent();
+        // Group text items by Y-coordinate (items on same line have similar Y values)
+        const textByY = new Map();
+        for (const item of textContent.items) {
+            const textItem = item;
+            // transform[5] is the Y coordinate
+            const yCoord = textItem.transform[5];
+            if (yCoord === undefined)
+                continue;
+            const y = Math.round(yCoord);
+            if (!textByY.has(y)) {
+                textByY.set(y, []);
+            }
+            textByY.get(y)?.push(textItem.str);
+        }
+        // Convert grouped text to content items
+        for (const [y, textParts] of textByY.entries()) {
+            const textContent = textParts.join('');
+            if (textContent.trim()) {
+                contentItems.push({
+                    type: 'text',
+                    yPosition: y,
+                    textContent,
+                });
+            }
+        }
+        // Extract images with Y-coordinates if requested
+        if (includeImages) {
+            const operatorList = await page.getOperatorList();
+            // Find all image painting operations
+            const imageIndices = [];
+            for (let i = 0; i < operatorList.fnArray.length; i++) {
+                const op = operatorList.fnArray[i];
+                if (op === OPS.paintImageXObject || op === OPS.paintXObject) {
+                    imageIndices.push(i);
+                }
+            }
+            // Extract each image with its Y-coordinate
+            const imagePromises = imageIndices.map((imgIndex, arrayIndex) => new Promise((resolve) => {
+                const argsArray = operatorList.argsArray[imgIndex];
+                if (!argsArray || argsArray.length === 0) {
+                    resolve(null);
+                    return;
+                }
+                const imageName = argsArray[0];
+                // Get transform matrix from the args (if available)
+                // The transform is typically in argsArray[1] for some ops
+                let yPosition = 0;
+                if (argsArray.length > 1 && Array.isArray(argsArray[1])) {
+                    const transform = argsArray[1];
+                    // transform[5] is the Y coordinate
+                    const yCoord = transform[5];
+                    if (yCoord !== undefined) {
+                        yPosition = Math.round(yCoord);
+                    }
+                }
+                // Use callback-based get() as images may not be resolved yet
+                page.objs.get(imageName, (imageData) => {
+                    if (!imageData || typeof imageData !== 'object') {
+                        resolve(null);
+                        return;
+                    }
+                    const img = imageData;
+                    if (!img.data || !img.width || !img.height) {
+                        resolve(null);
+                        return;
+                    }
+                    // Determine image format based on kind
+                    const format = img.kind === 1 ? 'grayscale' : img.kind === 3 ? 'rgba' : 'rgb';
+                    // Convert Uint8Array to base64
+                    const base64 = Buffer.from(img.data).toString('base64');
+                    resolve({
+                        type: 'image',
+                        yPosition,
+                        imageData: {
+                            page: pageNum,
+                            index: arrayIndex,
+                            width: img.width,
+                            height: img.height,
+                            format,
+                            data: base64,
+                        },
+                    });
+                });
+            }));
+            const resolvedImages = await Promise.all(imagePromises);
+            contentItems.push(...resolvedImages.filter((item) => item !== null));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[PDF Reader MCP] Error extracting page content for page ${String(pageNum)} in ${sourceDescription}: ${message}`);
+        // Return error message as text content
+        return [
+            {
+                type: 'text',
+                yPosition: 0,
+                textContent: `Error processing page: ${message}`,
+            },
+        ];
+    }
+    // Sort by Y-position (descending = top to bottom in PDF coordinates)
+    return contentItems.sort((a, b) => b.yPosition - a.yPosition);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/pdf-reader-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "An MCP server providing tools to read PDF files.",
   "type": "module",
   "bin": {