@juspay/neurolink 10.10.8 → 10.10.10

package/dist/utils/messageBuilder.js

@@ -4,6 +4,7 @@ import { getGlobalDispatcher, interceptors, request } from "undici";
 import { MultimodalLogger, ProviderImageAdapter, } from "../adapters/providerImageAdapter.js";
 import { CONVERSATION_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS, } from "../config/conversationMemory.js";
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
+import { PDF_LIMITS } from "../core/constants.js";
 import { enforceAggregateFileBudget, FILE_READ_BUDGET_PERCENT, } from "../context/fileTokenBudget.js";
 import { isCSVContent, SIZE_TIER_THRESHOLDS } from "../types/index.js";
 import { tracers, ATTR, withSpan } from "../telemetry/index.js";
@@ -1150,6 +1151,10 @@ async function processExplicitPdfFiles(options, maxSize, provider) {
                     // #260: carry the per-page canvas-pixel ceiling so the caller can
                     // raise (or lower) the memory guard for the image-fallback render.
                     maxCanvasPixels: options.pdfOptions?.maxCanvasPixels,
+                    // #297: render scale / page ceiling, so the lowered default is
+                    // actually reachable and callers can trade sharpness for memory.
+                    scale: options.pdfOptions?.scale,
+                    maxPages: options.pdfOptions?.maxPages,
                 });
                 logger.info(`[PDF] ✅ Queued for multimodal: ${filename} (${result.metadata?.estimatedPages ?? "unknown"} pages)`);
             }
@@ -1458,6 +1463,8 @@ async function convertContentToProviderFormat(content, provider, _model, pdfOpti
         // guard as the `input.pdfFiles` path (see `processExplicitPdfFiles`).
         password: pdfOptions?.password,
         maxCanvasPixels: pdfOptions?.maxCanvasPixels,
+        scale: pdfOptions?.scale,
+        maxPages: pdfOptions?.maxPages,
     }));
     // #309: same aggregate ceiling as `input.pdfFiles`. Without this, moving an
     // over-limit payload from `input.pdfFiles` to `input.content` skipped the
@@ -1809,7 +1816,10 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
 /**
  * Convert multimodal content (images + PDFs) to provider format
  */
-async function convertMultimodalToProviderFormat(text, images, pdfFiles, provider, model) {
+async function convertMultimodalToProviderFormat(text, images, 
+// The canonical entry shape (#309) rather than a fourth copy of it inline —
+// which is what let the render knobs stop short of this function.
+pdfFiles, provider, model) {
     const content = [
         { type: "text", text },
     ];
@@ -1843,14 +1853,41 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
         logger.info(`[PDF→Image] Provider ${provider} doesn't support native PDF. Converting ${pdfFiles.length} PDF(s) to images...`);
         for (const pdf of pdfFiles) {
             try {
+                const effectiveMaxPages = pdf.maxPages ?? PDF_LIMITS.DEFAULT_MAX_PAGES;
                 const conversionResult = await PDFImageConverter.convertToImages(pdf.buffer, {
-                    scale: 2.0, // High quality for OCR/analysis
-                    maxPages: 20, // Limit pages to prevent token overflow
+                    // #297: this is the only PDF→image call the product actually makes,
+                    // and it used to hardcode scale 2.0 — silently overriding the
+                    // lowered PDF_LIMITS.DEFAULT_SCALE and keeping the memory cost the
+                    // issue reports (a 100-page render at 2.0 is ~776MB; 1.5 is ~44%
+                    // fewer pixels per page). Callers can raise it back per request.
+                    scale: pdf.scale ?? PDF_LIMITS.DEFAULT_SCALE,
+                    // Page ceiling guards token overflow; also now caller-adjustable
+                    // rather than a constant nothing could reach.
+                    maxPages: effectiveMaxPages,
                     ...(pdf.password ? { password: pdf.password } : {}), // #258
                     ...(pdf.maxCanvasPixels
                         ? { maxCanvasPixels: pdf.maxCanvasPixels }
                         : {}), // #260
                 });
+                // The renderer stops at maxPages, so a longer document is silently
+                // truncated — say so rather than letting the model answer from a
+                // partial document as though it had the whole thing.
+                //
+                // Keyed on the cap being reached, not on pdf.pageCount: that field is
+                // null whenever `input.content` omits `metadata.pages`, which is the
+                // common case, so a page-count comparison would simply never fire
+                // there. Reaching the cap is also unambiguous — a short count caused by
+                // per-page render failures (#294 isolates those into `errors`) would
+                // otherwise be misreported as a maxPages truncation.
+                if (conversionResult.pageCount >= effectiveMaxPages) {
+                    logger.warn(`[PDF→Image] ${safeBasename(pdf.filename)} hit the ${effectiveMaxPages}-page ` +
+                        `conversion limit. Any pages beyond that were not sent — the model may be ` +
+                        `answering from a partial document. Raise pdfOptions.maxPages or split the file.`);
+                }
+                if (conversionResult.errors && conversionResult.errors.length > 0) {
+                    logger.warn(`[PDF→Image] ${safeBasename(pdf.filename)}: ${conversionResult.errors.length} page(s) ` +
+                        `failed to render and were omitted (page ${conversionResult.errors.map((e) => e.page).join(", ")}).`);
+                }
                 logger.info(`[PDF→Image] ✅ Converted ${pdf.filename}: ${conversionResult.pageCount} page(s) → images`);
                 // Add each page as an ImagePart (raw base64, not data: URI — see SSRF note above)
                 conversionResult.images.forEach((base64Image, pageIndex) => {

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -58,6 +58,8 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
     pdfOptions: {
         password?: string;
         maxCanvasPixels?: number;
+        scale?: number;
+        maxPages?: number;
     } | undefined;
     systemPrompt: string | undefined;
     conversationHistory: import("../index.js").ChatMessage[] | undefined;

package/dist/utils/pdfProcessor.js

@@ -377,6 +377,7 @@ export class PDFProcessor {
             format,
             scale,
             maxCanvasPixels,
+            maxPages,
         });
         logger.debug("[PDF→Image] ✅ PDF validation passed", {
             bufferSize: pdfBuffer.length,
@@ -535,6 +536,14 @@ export class PDFProcessor {
         if (!Number.isFinite(opts.maxCanvasPixels) || opts.maxCanvasPixels <= 0) {
             throw new Error(`Invalid maxCanvasPixels: ${opts.maxCanvasPixels}. Must be a finite number greater than 0.`);
         }
+        // #297: maxPages became caller-controlled, and an unvalidated 0/-1/NaN
+        // silently converts nothing, surfacing later as a misleading
+        // "PDF has 0 pages" from deep inside the renderer. Reject it here where
+        // the message can still name the offending option.
+        if (opts.maxPages !== undefined &&
+            (!Number.isInteger(opts.maxPages) || opts.maxPages < 1)) {
+            throw new Error(`Invalid maxPages: ${opts.maxPages}. Must be a whole number of at least 1.`);
+        }
         if (!pdfBuffer || pdfBuffer.length < 5) {
             throw new Error("Invalid PDF: Buffer is too small or empty. " +
                 "A valid PDF must be at least 5 bytes (PDF header).");
@@ -570,6 +579,7 @@ export class PDFProcessor {
             format,
             scale,
             maxCanvasPixels,
+            maxPages,
         });
         const pdfToImgModule = await import("pdf-to-img");
         const pdf = pdfToImgModule.pdf;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.10.8",
+  "version": "10.10.10",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {