@juspay/neurolink 12.21.2 → 12.22.1

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -250,6 +250,28 @@ export declare function buildTurnStalledMessage(stallTimeoutMs: number, toolCall
  * short-circuit — stopReason "aborted").
  */
 export declare function buildAbortedTurnMessage(toolCallCount: number): string;
+/**
+ * Pick the honest terminal message for a native-loop exit by its ACTUAL
+ * cause. The step-cap text is the fallback for genuine budget exhaustion
+ * only — time/stall/abort exits must never claim a step limit was reached
+ * (the 2026-07-03 "reached the 200-step limit" incident was a wall-clock
+ * abort wearing the cap message).
+ *
+ * Takes plain booleans rather than a turn clock so a loop whose wall-clock
+ * deadline is owned by something other than `createTurnClock` — AI Studio's
+ * pre-existing per-request timeout controller — can report through the same
+ * builders instead of growing a second set.
+ */
+export declare function buildLoopExitMessage(params: {
+    timedOut: boolean;
+    stalled: boolean;
+    /** Turn duration so far, for the time-limit message. */
+    elapsedMs: number;
+    wasAborted: boolean;
+    stallTimeoutMs?: number;
+    maxSteps: number;
+    toolCallCount: number;
+}): string;
 /**
  * Wrap-up nudge injected when the remaining turn time drops inside the
  * `wrapupTimeLeadMs` window — the time-budget twin of the soft step-budget

package/dist/providers/googleNativeGemini3/utils.js

@@ -922,6 +922,30 @@ export function buildAbortedTurnMessage(toolCallCount) {
         : "";
     return `This turn was stopped before I could finish.${calls}`;
 }
+/**
+ * Pick the honest terminal message for a native-loop exit by its ACTUAL
+ * cause. The step-cap text is the fallback for genuine budget exhaustion
+ * only — time/stall/abort exits must never claim a step limit was reached
+ * (the 2026-07-03 "reached the 200-step limit" incident was a wall-clock
+ * abort wearing the cap message).
+ *
+ * Takes plain booleans rather than a turn clock so a loop whose wall-clock
+ * deadline is owned by something other than `createTurnClock` — AI Studio's
+ * pre-existing per-request timeout controller — can report through the same
+ * builders instead of growing a second set.
+ */
+export function buildLoopExitMessage(params) {
+    if (params.timedOut) {
+        return buildTurnTimeoutMessage(params.elapsedMs, params.toolCallCount);
+    }
+    if (params.stalled) {
+        return buildTurnStalledMessage(params.stallTimeoutMs ?? 0, params.toolCallCount);
+    }
+    if (params.wasAborted) {
+        return buildAbortedTurnMessage(params.toolCallCount);
+    }
+    return buildToolLoopCapMessage(params.maxSteps, params.toolCallCount);
+}
 /**
  * Wrap-up nudge injected when the remaining turn time drops inside the
  * `wrapupTimeLeadMs` window — the time-budget twin of the soft step-budget

package/dist/providers/googleVertex/client.d.ts

@@ -300,18 +300,9 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     private emitGenerationEnd;
     /**
-     * Emit a `turn:lifecycle` event on the SDK emitter (alongside
-     * tool:start/tool:end) so loop conditions that previously only reached
-     * process logs — step-cap, time-limit, stall, abort, tool timeouts,
-     * malformed-call retries — are observable by consumers' own pipelines.
-     */
-    private emitTurnEvent;
-    /**
-     * Pick the honest terminal message for a native-loop exit by its ACTUAL
-     * cause. The step-cap text is the fallback for genuine budget exhaustion
-     * only — time/stall/abort exits must never claim a step limit was reached
-     * (the 2026-07-03 "reached the 200-step limit" incident was a wall-clock
-     * abort wearing the cap message).
+     * Turn-clock-shaped adapter over the shared {@link buildLoopExitMessage}.
+     * Every call site in this file holds a clock, so the mapping lives here
+     * rather than at ten call sites; the decision itself is the shared one.
      */
     private buildLoopExitMessage;
     protected formatProviderError(error: unknown): Error;

package/dist/providers/googleVertex/client.js

@@ -32,7 +32,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } fr
 import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { TimeoutError, withTimeout } from "../../utils/async/index.js";
 import { parseTimeout } from "../../utils/timeout.js";
-import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildDedupedEngineTools, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { appendStepText, buildContextCapMessage, buildDedupedEngineTools, buildLoopExitMessage, buildToolLoopCapMessage, buildWrapupNudgeText, createContextGuard, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { createAnthropicLoopAdapter } from "../anthropic/loopAdapter.js";
@@ -5697,41 +5697,22 @@ export class GoogleVertexProvider extends BaseProvider {
         }
     }
     /**
-     * Emit a `turn:lifecycle` event on the SDK emitter (alongside
-     * tool:start/tool:end) so loop conditions that previously only reached
-     * process logs — step-cap, time-limit, stall, abort, tool timeouts,
-     * malformed-call retries — are observable by consumers' own pipelines.
-     */
-    emitTurnEvent(payload) {
-        try {
-            this.neurolink?.getEventEmitter()?.emit("turn:lifecycle", {
-                provider: this.providerName,
-                timestamp: Date.now(),
-                ...payload,
-            });
-        }
-        catch {
-            /* listener errors are non-fatal */
-        }
-    }
-    /**
-     * Pick the honest terminal message for a native-loop exit by its ACTUAL
-     * cause. The step-cap text is the fallback for genuine budget exhaustion
-     * only — time/stall/abort exits must never claim a step limit was reached
-     * (the 2026-07-03 "reached the 200-step limit" incident was a wall-clock
-     * abort wearing the cap message).
+     * Turn-clock-shaped adapter over the shared {@link buildLoopExitMessage}.
+     * Every call site in this file holds a clock, so the mapping lives here
+     * rather than at ten call sites; the decision itself is the shared one.
      */
     buildLoopExitMessage(params) {
-        if (params.turnClock.timedOut) {
-            return buildTurnTimeoutMessage(params.turnClock.elapsedMs(), params.toolCallCount);
-        }
-        if (params.turnClock.stalled) {
-            return buildTurnStalledMessage(params.stallTimeoutMs ?? 0, params.toolCallCount);
-        }
-        if (params.wasAborted) {
-            return buildAbortedTurnMessage(params.toolCallCount);
-        }
-        return buildToolLoopCapMessage(params.maxSteps, params.toolCallCount);
+        return buildLoopExitMessage({
+            timedOut: params.turnClock.timedOut,
+            stalled: params.turnClock.stalled,
+            elapsedMs: params.turnClock.elapsedMs(),
+            wasAborted: params.wasAborted,
+            ...(params.stallTimeoutMs !== undefined
+                ? { stallTimeoutMs: params.stallTimeoutMs }
+                : {}),
+            maxSteps: params.maxSteps,
+            toolCallCount: params.toolCallCount,
+        });
     }
     formatProviderError(error) {
         const errorRecord = error;

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;

package/dist/utils/stringDistance.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared string-distance helpers for "did you mean?" suggestions.
+ *
+ * Extracted from toolCallRepair.ts, which had the only implementation, so
+ * provider-name validation can reuse it rather than carry a second copy.
+ */
+/**
+ * Longest string the distance primitive will compare.
+ *
+ * Exported so every call site can apply the same limit *before* calling
+ * `levenshtein` — skipping an over-limit operand entirely, rather than
+ * comparing a truncated prefix of it. Truncating silently merged any two
+ * strings that happened to share their first `MAX_COMPARABLE_LENGTH`
+ * characters into distance 0, which let a direct MCP tool-name lookup
+ * (`resolveToolName`) resolve to the wrong tool for a long, colliding name.
+ */
+export declare const MAX_COMPARABLE_LENGTH = 128;
+/**
+ * Compute Levenshtein edit distance between two strings.
+ * Uses the iterative matrix approach — O(m*n) time, O(min(m,n)) space.
+ *
+ * Throws rather than truncating when either input exceeds
+ * `MAX_COMPARABLE_LENGTH`: silently comparing truncated prefixes produces a
+ * *wrong* distance (two distinct strings sharing a long prefix collapse to
+ * distance 0) instead of no distance, which is worse than refusing outright.
+ * Callers that want fuzzy matching over long input must apply the length
+ * check themselves and skip the comparison — see `suggestClosest` below and
+ * `resolveToolName`/`rankToolNameCandidates` in toolCallRepair.ts.
+ */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Candidates within `maxDistance` edits of `input`, closest first.
+ *
+ * Ties break on the candidate's own order in `candidates`, so a caller that
+ * passes canonical names before aliases gets the canonical one suggested.
+ * Comparison is case-insensitive; the returned strings keep their original
+ * casing so they can be pasted back verbatim.
+ *
+ * `input` longer than `MAX_COMPARABLE_LENGTH` is rejected outright (no
+ * suggestions), and any individual candidate over the same limit is skipped
+ * rather than compared — never truncated. Truncating either side risks
+ * exactly the false distance-0 match `levenshtein`'s guard rejects: two
+ * distinct strings sharing a long-enough prefix would otherwise look
+ * identical and "suggest" the wrong one.
+ *
+ * @param input - The string the user actually typed
+ * @param candidates - Valid values, most-preferred first
+ * @param options.maxDistance - Edit budget (default 3)
+ * @param options.limit - Most suggestions to return (default 3)
+ */
+export declare function suggestClosest(input: string, candidates: readonly string[], options?: {
+    maxDistance?: number;
+    limit?: number;
+}): string[];