@juspay/neurolink 12.22.0 → 12.22.1

package/dist/core/constants.js

@@ -311,7 +311,7 @@ export const PDF_LIMITS = {
     DEFAULT_MAX_CANVAS_PIXELS: 16_777_216,
     // Floor for the downscaled render scale (#260 follow-up). A crafted/malformed
     // MediaBox can drive the estimated pixel count toward Infinity, which would
-    // otherwise collapse `effectiveScale` to 0 and hand `pdf-to-img` a degenerate
+    // otherwise collapse `effectiveScale` to 0 and hand the renderer a degenerate
     // viewport. Never let the downscale branch go below this.
     MIN_EFFECTIVE_SCALE: 0.1,
 };

package/dist/providers/openaiChatCompletionsClient.d.ts

@@ -37,6 +37,10 @@ export declare const buildWireToolNameMaps: (names: readonly string[], reservedW
  * tool definitions). Used by the per-request max_tokens fit against a
  * RUNTIME-DISCOVERED context window — deliberately the same char-based
  * estimator the budget pipeline uses, so both layers agree.
+ *
+ * Image parts are billed at the flat IMAGE_TOKEN_ESTIMATE, never by the length
+ * of their base64 data URL: a PDF rendered to 10 page images otherwise
+ * stringifies to ~1.2M "tokens" and is rejected before it is ever sent.
  */
 export declare const estimateWireTokens: (messages: ReadonlyArray<OpenAICompatChatMessage>, tools: OpenAICompatChatTool[] | undefined, provider?: string) => number;
 export declare const safeStringify: (value: unknown) => string;

package/dist/providers/openaiChatCompletionsClient.js

@@ -17,7 +17,7 @@ import { createParser } from "eventsource-parser";
 import { sanitizeToolName } from "../mcp/toolConverter.js";
 import { resolveSamplingParams } from "../models/modelRegistry.js";
 import { convertZodToJsonSchema, normalizeWireToolSchema, } from "../utils/schemaConversion.js";
-import { estimateTokens, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
+import { estimateTokens, IMAGE_TOKEN_ESTIMATE, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
 export const stripTrailingSlash = (s) => s.replace(/\/+$/, "");
 // OpenAI-compatible wire tool names: first char letter/underscore (some
 // chat templates treat a leading digit or hyphen as invalid identifiers),
@@ -68,14 +68,29 @@ export const buildWireToolNameMaps = (names, reservedWireNames) => {
  * tool definitions). Used by the per-request max_tokens fit against a
  * RUNTIME-DISCOVERED context window — deliberately the same char-based
  * estimator the budget pipeline uses, so both layers agree.
+ *
+ * Image parts are billed at the flat IMAGE_TOKEN_ESTIMATE, never by the length
+ * of their base64 data URL: a PDF rendered to 10 page images otherwise
+ * stringifies to ~1.2M "tokens" and is rejected before it is ever sent.
  */
 export const estimateWireTokens = (messages, tools, provider) => {
     let total = 0;
     for (const message of messages) {
-        const content = typeof message.content === "string"
-            ? message.content
-            : safeStringify(message.content);
-        total += estimateTokens(content, provider) + TOKENS_PER_MESSAGE;
+        if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                total +=
+                    part.type === "image_url"
+                        ? IMAGE_TOKEN_ESTIMATE
+                        : estimateTokens(part.text, provider);
+            }
+            total += TOKENS_PER_MESSAGE;
+        }
+        else {
+            const content = typeof message.content === "string"
+                ? message.content
+                : safeStringify(message.content);
+            total += estimateTokens(content, provider) + TOKENS_PER_MESSAGE;
+        }
         // tool_calls only exists on the assistant variant of the message union.
         const toolCalls = message.tool_calls;
         if (toolCalls) {

package/dist/types/file.d.ts

@@ -552,6 +552,19 @@ export type PDFImagePage = {
     /** Populated when this page failed to render (#294). */
     error?: string;
 };
+/**
+ * A PDF opened for page rendering. Rendering goes through pdf-parse so the
+ * process loads exactly one pdfjs-dist copy — a second copy fails pdfjs's
+ * API-vs-Worker version check for whichever library loads second.
+ */
+export type PDFRenderDocument = {
+    /** Total pages in the document. */
+    length: number;
+    /** Render a 1-based page to a PNG buffer. */
+    getPage: (pageNumber: number) => Promise<Buffer>;
+    /** Release pdfjs resources held by the document. */
+    destroy: () => Promise<void>;
+};
 /**
  * A single PDF queued for multimodal message building, normalised from either
  * submission surface — `input.pdfFiles` or `input.content` with `type: "pdf"`

package/dist/utils/pdfProcessor.d.ts

@@ -5,7 +5,10 @@
  * - Native PDF support for providers that accept PDF directly (Google AI, Vertex, OpenAI, Anthropic, Bedrock)
  * - PDF → Image conversion for providers that don't support native PDF (Azure, Mistral, Ollama)
  *
- * The conversion uses pdf-to-img package (MuPDF-based) for high-quality conversion.
+ * Page counting, text extraction and page rendering all go through pdf-parse,
+ * so the process only ever loads pdf-parse's pdfjs-dist. pdfjs keeps its Node
+ * worker in a process-wide global, and a second pdfjs version fails its
+ * API-vs-Worker version check against whichever copy loaded first.
  */
 import type { FileProcessingResult, PDFProcessorOptions, PDFProviderConfig, PDFImageConversionOptions, PDFImageConversionResult, PDFImagePage } from "../types/index.js";
 export declare class PDFProcessor {
@@ -40,6 +43,21 @@ export declare class PDFProcessor {
      * falls back to the regex estimate.
      */
     private static getAccuratePageCount;
+    /**
+     * Font and CMap directories of the pdfjs-dist copy pdf-parse itself loads,
+     * so non-embedded standard fonts and CJK text render instead of dropping
+     * out. Resolved from pdf-parse's location, never our own, to stay on that
+     * single copy. Undefined when resolution fails; rendering still works, with
+     * pdfjs falling back to its built-in font substitution.
+     */
+    private static pdfjsAssetDirs;
+    private static resolvePdfjsAssetDirs;
+    /**
+     * Open a PDF for page-by-page PNG rendering through pdf-parse. Rejects with
+     * pdf-parse's PasswordException for encrypted PDFs (#258), which the callers
+     * map to typed errors.
+     */
+    private static openForRendering;
     static estimateTokens(pageCount: number, mode?: "text-only" | "visual"): number;
     /**
      * Estimate the largest page's rendered pixel count from the PDF's MediaBox
@@ -96,7 +114,7 @@ export declare class PDFProcessor {
      *
      * NOT a wrapper of/over {@link convertToImages}, despite the similar
      * contract — the two are independent, parallel implementations (each does
-     * its own `pdf-to-img` import, downscale calculation, and page loop)
+     * its own document open, downscale calculation, and page loop)
      * rather than one delegating to the other. Keep behavior changes (page
      * isolation, downscale, password handling) in sync across both by hand.
      */
@@ -113,7 +131,7 @@ export declare class PDFProcessor {
      * Check if PDF to image conversion is available
      * Useful for feature detection
      *
-     * @returns true if pdf-to-img package is available
+     * @returns true if the pdf-parse renderer is available
      */
     static isImageConversionAvailable(): Promise<boolean>;
     /**

package/dist/utils/pdfProcessor.js

@@ -5,8 +5,13 @@
  * - Native PDF support for providers that accept PDF directly (Google AI, Vertex, OpenAI, Anthropic, Bedrock)
  * - PDF → Image conversion for providers that don't support native PDF (Azure, Mistral, Ollama)
  *
- * The conversion uses pdf-to-img package (MuPDF-based) for high-quality conversion.
+ * Page counting, text extraction and page rendering all go through pdf-parse,
+ * so the process only ever loads pdf-parse's pdfjs-dist. pdfjs keeps its Node
+ * worker in a process-wide global, and a second pdfjs version fails its
+ * API-vs-Worker version check against whichever copy loaded first.
  */
+import { createRequire } from "node:module";
+import path from "node:path";
 import { PDF_LIMITS } from "../core/constants.js";
 import { ErrorFactory } from "./errorHandling.js";
 import { logger } from "./logger.js";
@@ -297,6 +302,76 @@ export class PDFProcessor {
             return null;
         }
     }
+    /**
+     * Font and CMap directories of the pdfjs-dist copy pdf-parse itself loads,
+     * so non-embedded standard fonts and CJK text render instead of dropping
+     * out. Resolved from pdf-parse's location, never our own, to stay on that
+     * single copy. Undefined when resolution fails; rendering still works, with
+     * pdfjs falling back to its built-in font substitution.
+     */
+    static pdfjsAssetDirs;
+    static resolvePdfjsAssetDirs() {
+        if (PDFProcessor.pdfjsAssetDirs === undefined) {
+            try {
+                const pdfParseEntry = createRequire(import.meta.url).resolve("pdf-parse");
+                const pdfjsRoot = path.dirname(createRequire(pdfParseEntry).resolve("pdfjs-dist/package.json"));
+                PDFProcessor.pdfjsAssetDirs = {
+                    standardFontDataUrl: path.join(pdfjsRoot, "standard_fonts") + path.sep,
+                    cMapUrl: path.join(pdfjsRoot, "cmaps") + path.sep,
+                };
+            }
+            catch (error) {
+                logger.debug(`[PDF→Image] pdfjs font/CMap directories unavailable: ${error instanceof Error ? error.message : String(error)}`);
+                PDFProcessor.pdfjsAssetDirs = null;
+            }
+        }
+        return PDFProcessor.pdfjsAssetDirs ?? undefined;
+    }
+    /**
+     * Open a PDF for page-by-page PNG rendering through pdf-parse. Rejects with
+     * pdf-parse's PasswordException for encrypted PDFs (#258), which the callers
+     * map to typed errors.
+     */
+    static async openForRendering(pdfBuffer, scale, password) {
+        const { PDFParse } = await import("pdf-parse");
+        const parser = new PDFParse({
+            data: new Uint8Array(pdfBuffer),
+            isEvalSupported: false,
+            cMapPacked: true,
+            ...PDFProcessor.resolvePdfjsAssetDirs(),
+            ...(password ? { password } : {}),
+        });
+        try {
+            const { total } = await parser.getInfo();
+            return {
+                length: total,
+                getPage: async (pageNumber) => {
+                    const shot = await parser.getScreenshot({
+                        partial: [pageNumber],
+                        scale,
+                        imageBuffer: true,
+                        imageDataUrl: false,
+                    });
+                    const page = shot.pages[0];
+                    if (!page || page.data.length === 0) {
+                        throw new Error(`page ${pageNumber} rendered no image data`);
+                    }
+                    return Buffer.from(page.data);
+                },
+                destroy: async () => {
+                    await parser.destroy().catch(() => {
+                        /* cleanup - ignore destroy errors */
+                    });
+                },
+            };
+        }
+        catch (error) {
+            await parser.destroy().catch(() => {
+                /* cleanup - ignore destroy errors */
+            });
+            throw error;
+        }
+    }
     static estimateTokens(pageCount, mode = "visual") {
         if (mode === "text-only") {
             return Math.ceil((pageCount / 3) * 1000);
@@ -395,16 +470,14 @@ export class PDFProcessor {
             estimatedMemoryMB,
             sizeMB: Number(sizeMB.toFixed(2)),
         });
+        let document;
         try {
-            // Dynamic import to avoid loading MuPDF binaries until needed
-            const pdfToImgModule = await import("pdf-to-img");
-            const pdf = pdfToImgModule.pdf;
             logger.debug("[PDF→Image] Starting PDF to image conversion", {
                 bufferSize: pdfBuffer.length,
                 scale,
                 maxPages: maxPages || "all",
             });
-            // #260: pre-flight page-size check WITHOUT rendering. pdf-to-img applies
+            // #260: pre-flight page-size check WITHOUT rendering. The renderer applies
             // `scale` uniformly with no per-page hook and no pixel guard, so a very
             // large page (e.g. an architectural drawing with a huge MediaBox) can
             // allocate gigabytes of canvas. Read the largest MediaBox from the PDF
@@ -416,7 +489,7 @@ export class PDFProcessor {
                 const downscale = Math.sqrt(maxCanvasPixels / largestPixels);
                 // Floor the result: an astronomically large (but now finite, see
                 // `largestPagePixels`) pixel estimate would otherwise push `downscale`
-                // — and therefore `effectiveScale` — toward 0, handing `pdf-to-img` a
+                // — and therefore `effectiveScale` — toward 0, handing the renderer a
                 // degenerate viewport instead of a small-but-renderable page.
                 effectiveScale = Math.max(PDF_LIMITS.MIN_EFFECTIVE_SCALE, scale * downscale);
                 // Recompute the ratio actually applied (may differ from `downscale`
@@ -431,14 +504,9 @@ export class PDFProcessor {
                 logger.warn(`[PDF→Image] ⚠️ ${msg}`);
                 warnings.push(msg);
             }
-            // Create PDF document (password forwarded for encrypted PDFs, #258).
-            // pdf-to-img resolves `.length` (numPages) synchronously here and exposes
-            // `.getPage(n)`, so we drive an indexed loop rather than the async
-            // iterator — that lets one bad page be isolated instead of aborting all.
-            const document = await pdf(pdfBuffer, {
-                scale: effectiveScale,
-                ...(password ? { password } : {}),
-            });
+            // Password forwarded for encrypted PDFs (#258). An indexed getPage()
+            // loop lets one bad page be isolated instead of aborting all.
+            document = await PDFProcessor.openForRendering(pdfBuffer, effectiveScale, password);
             const totalPages = document.length;
             // #294: convert page-by-page with per-page isolation. A single page whose
             // canvas render throws (e.g. a degenerate MediaBox) no longer discards
@@ -518,6 +586,9 @@ export class PDFProcessor {
                 cause: error,
             });
         }
+        finally {
+            await document?.destroy();
+        }
     }
     /**
      * Shared input validation for the image-conversion paths. Returns the PDF
@@ -568,7 +639,7 @@ export class PDFProcessor {
      *
      * NOT a wrapper of/over {@link convertToImages}, despite the similar
      * contract — the two are independent, parallel implementations (each does
-     * its own `pdf-to-img` import, downscale calculation, and page loop)
+     * its own document open, downscale calculation, and page loop)
      * rather than one delegating to the other. Keep behavior changes (page
      * isolation, downscale, password handling) in sync across both by hand.
      */
@@ -581,8 +652,6 @@ export class PDFProcessor {
             maxCanvasPixels,
             maxPages,
         });
-        const pdfToImgModule = await import("pdf-to-img");
-        const pdf = pdfToImgModule.pdf;
         // #260: uniform downscale so the largest page stays under maxCanvasPixels.
         let effectiveScale = scale;
         const largestPixels = PDFProcessor.largestPagePixels(pdfBuffer, scale);
@@ -596,10 +665,7 @@ export class PDFProcessor {
         // being yielded as a page error.
         let document;
         try {
-            document = await pdf(pdfBuffer, {
-                scale: effectiveScale,
-                ...(password ? { password } : {}),
-            });
+            document = await PDFProcessor.openForRendering(pdfBuffer, effectiveScale, password);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -617,33 +683,43 @@ export class PDFProcessor {
         }
         const totalPages = document.length;
         let converted = 0;
-        for (let pageNum = 1; pageNum <= totalPages; pageNum++) {
-            if (maxPages !== undefined && pageNum - 1 >= maxPages) {
-                break;
-            }
-            try {
-                const page = await document.getPage(pageNum);
-                const base64Image = page.toString("base64");
-                converted++;
-                if (onProgress) {
-                    await onProgress({
-                        pagesConverted: converted,
-                        totalPages,
-                        elapsedMs: Date.now() - startTime,
-                    });
+        try {
+            for (let pageNum = 1; pageNum <= totalPages; pageNum++) {
+                if (maxPages !== undefined && pageNum - 1 >= maxPages) {
+                    break;
+                }
+                try {
+                    const page = await document.getPage(pageNum);
+                    const base64Image = page.toString("base64");
+                    converted++;
+                    if (onProgress) {
+                        await onProgress({
+                            pagesConverted: converted,
+                            totalPages,
+                            elapsedMs: Date.now() - startTime,
+                        });
+                    }
+                    yield {
+                        pageIndex: pageNum,
+                        image: base64Image,
+                        imageSizeBytes: page.length,
+                    };
+                }
+                catch (pageError) {
+                    const msg = pageError instanceof Error ? pageError.message : String(pageError);
+                    logger.warn(`[PDF→Image] ⚠️ page ${pageNum} failed to render (stream): ${msg}`);
+                    yield {
+                        pageIndex: pageNum,
+                        image: "",
+                        imageSizeBytes: 0,
+                        error: msg,
+                    };
                 }
-                yield {
-                    pageIndex: pageNum,
-                    image: base64Image,
-                    imageSizeBytes: page.length,
-                };
-            }
-            catch (pageError) {
-                const msg = pageError instanceof Error ? pageError.message : String(pageError);
-                logger.warn(`[PDF→Image] ⚠️ page ${pageNum} failed to render (stream): ${msg}`);
-                yield { pageIndex: pageNum, image: "", imageSizeBytes: 0, error: msg };
             }
         }
+        finally {
+            await document.destroy();
+        }
     }
     /**
      * Convert a PDF file path to an array of base64 PNG images
@@ -661,11 +737,11 @@ export class PDFProcessor {
      * Check if PDF to image conversion is available
      * Useful for feature detection
      *
-     * @returns true if pdf-to-img package is available
+     * @returns true if the pdf-parse renderer is available
      */
     static async isImageConversionAvailable() {
         try {
-            await import("pdf-to-img");
+            await import("pdf-parse");
             return true;
         }
         catch {
@@ -683,7 +759,7 @@ export class PDFProcessor {
     static estimateConversionMemoryUsage(pdfSizeBytes, pageCount, scale = PDF_LIMITS.DEFAULT_SCALE) {
         // Rough estimation:
         // - Each page at scale 2 produces ~1-3MB PNG
-        // - MuPDF needs ~2x PDF size for processing
+        // - pdfjs needs ~2x PDF size for processing
         // - Output images need ~2MB per page on average
         const pdfProcessingMB = (pdfSizeBytes / (1024 * 1024)) * 2;
         const outputImagesMB = pageCount * 2 * scale;