@juspay/neurolink 12.19.2 → 12.20.0

package/dist/cli/loop/optionsSchema.d.ts

@@ -4,4 +4,4 @@ import type { OptionSchema, TextGenerationOptions } from "../../types/index.js";
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "pdfOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials" | "onFinish" | "onError" | "processors" | "piiDetection" | "responseValidation" | "inputValidation" | "toolExecutionCapture" | "toolExecutionRecorder">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "pdfOptions" | "imageOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials" | "onFinish" | "onError" | "processors" | "piiDetection" | "responseValidation" | "inputValidation" | "toolExecutionCapture" | "toolExecutionRecorder">, OptionSchema>;

package/dist/core/modules/MessageBuilder.js

@@ -104,6 +104,7 @@ export class MessageBuilder {
                     },
                     csvOptions: options.csvOptions,
                     pdfOptions: options.pdfOptions,
+                    imageOptions: options.imageOptions,
                     provider: options.provider,
                     model: options.model,
                     temperature: options.temperature,
@@ -226,6 +227,7 @@ export class MessageBuilder {
                     },
                     csvOptions: options.csvOptions,
                     pdfOptions: options.pdfOptions,
+                    imageOptions: options.imageOptions,
                     provider: options.provider,
                     model: options.model,
                     temperature: options.temperature,

package/dist/neurolink.js

@@ -4210,6 +4210,7 @@ Current user's request: ${currentInput}`;
             // reached convertToImages.
             csvOptions: options.csvOptions,
             pdfOptions: options.pdfOptions,
+            imageOptions: options.imageOptions,
             region: options.region,
             tts: options.tts,
             stt: options.stt,

package/dist/processors/config/fileExtensions.d.ts

@@ -13,7 +13,14 @@
  */
 /**
  * Image file extensions supported by the platform.
- * Includes `.svg`, which is processed as sanitized markup rather than raster.
+ *
+ * Includes `.svg`. On the processor path (`SvgProcessor`) that guarantees
+ * sanitized markup, never raster bytes — but that guarantee is scoped to
+ * that one consumer. This constant is also consumed by code that treats
+ * every image extension as raster (captioning, multimodal embedding, vision
+ * adapters); `.svg` is markup there too, just without the sanitization, so
+ * each such consumer must explicitly handle or reject `.svg` itself rather
+ * than assume this list implies raster-safety.
  */
 export declare const IMAGE_EXTENSIONS: readonly string[];
 /**

package/dist/processors/config/fileExtensions.js

@@ -17,7 +17,14 @@ import { extensionsForModality } from "./fileTypeRegistry.js";
 // =============================================================================
 /**
  * Image file extensions supported by the platform.
- * Includes `.svg`, which is processed as sanitized markup rather than raster.
+ *
+ * Includes `.svg`. On the processor path (`SvgProcessor`) that guarantees
+ * sanitized markup, never raster bytes — but that guarantee is scoped to
+ * that one consumer. This constant is also consumed by code that treats
+ * every image extension as raster (captioning, multimodal embedding, vision
+ * adapters); `.svg` is markup there too, just without the sanitization, so
+ * each such consumer must explicitly handle or reject `.svg` itself rather
+ * than assume this list implies raster-safety.
  */
 export const IMAGE_EXTENSIONS = extensionsForModality("image");
 /**

package/dist/rag/pipeline/RAGPipeline.js

@@ -26,6 +26,7 @@
  * ```
  */
 import { randomUUID } from "crypto";
+import { extname } from "path";
 import { MDocument } from "../document/MDocument.js";
 import { loadDocument } from "../document/loaders.js";
 import { InMemoryVectorStore } from "../retrieval/vectorQueryTool.js";
@@ -472,6 +473,19 @@ export class RAGPipeline {
         let chunksCreated = 0;
         for (const source of sources) {
             try {
+                if (typeof source === "string") {
+                    // IMAGE_EXTENSIONS includes .svg, but that constant's raster
+                    // guarantee is scoped to the processor path (SvgProcessor). Here
+                    // it would flow raw markup bytes into generateImageCaption (which
+                    // base64s them into a vision call) and into the multi-modal embed
+                    // call — both raster-only. Mirrors the identical skip in
+                    // ragIntegration.ts's ingestion-tool entry point so the two agree.
+                    const withoutQueryOrFragment = source.split(/[?#]/)[0];
+                    if (extname(withoutQueryOrFragment).toLowerCase() === ".svg") {
+                        logger.warn(`[RAGPipeline] SVG is not supported as a multi-modal image source, skipping: ${redactUrlForError(source)}`);
+                        continue;
+                    }
+                }
                 // Load the image
                 let imageDoc;
                 if (Buffer.isBuffer(source)) {
@@ -484,6 +498,21 @@ export class RAGPipeline {
                 else {
                     imageDoc = await this.imageLoader.load(source);
                 }
+                // The extension check above is necessary but not sufficient: it only
+                // sees the name. A source with no `.svg` suffix — an extension-less
+                // URL, or a local file named without one — reaches ImageLoader, which
+                // falls back to detecting the type from the bytes and returns
+                // `image/svg+xml` for markup starting `<svg`/`<?xm`. So re-check the
+                // resolved type AND the bytes: loadFromPath prefers a recognized
+                // extension over content detection, so SVG markup named `.png` keeps
+                // an image/png label. Skip rather than throw so SVG behaves the same
+                // whichever way it was identified. `supportedFormats` does not cover
+                // this: it is optional, and unset on the default config.
+                if (imageDoc.mimeType === "image/svg+xml" ||
+                    ImageProcessor.detectImageType(imageDoc.image) === "image/svg+xml") {
+                    logger.warn(`[RAGPipeline] SVG is not supported as a multi-modal image source, skipping: ${redactUrlForError(imageDoc.metadata.source)}`);
+                    continue;
+                }
                 const { supportedFormats } = this.multiModalConfig;
                 if (supportedFormats && !supportedFormats.includes(imageDoc.mimeType)) {
                     throw ErrorFactory.invalidParameters("ingestImages", new Error(`unsupported image MIME type: ${imageDoc.mimeType}`), { mimeType: imageDoc.mimeType, supportedFormats });

package/dist/rag/ragIntegration.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlForError } from "../utils/logSanitize.js";
+import { ImageProcessor } from "../utils/imageProcessor.js";
 import { createChunker } from "./ChunkerFactory.js";
 import { createVectorQueryTool, InMemoryVectorStore, } from "./retrieval/vectorQueryTool.js";
 import { ImageLoader } from "./document/imageLoader.js";
@@ -300,6 +301,25 @@ async function _prepareRAGToolInner(ragConfig, fallbackProvider) {
         for (const { path: imgPath } of imageFiles) {
             try {
                 const imageDoc = await imageLoader.load(imgPath);
+                // The two `ext === ".svg"` checks above are a cheap early-out, not the
+                // boundary: both match the NAME exactly, and the name is not what
+                // decides the type. ImageLoader resolves it two ways that disagree
+                // with a bare `.svg` comparison — `.svgz` maps to image/svg+xml
+                // through EXTENSION_MIME_MAP, and loadFromURL ignores the extension
+                // entirely and sniffs the bytes, so any image-extension URL actually
+                // serving SVG resolves to image/svg+xml here. A local raster suffix
+                // has the opposite problem: loadFromPath trusts the extension before
+                // the bytes, so inspect both. Otherwise `hasImage: true` below sends
+                // SVG markup to the raster embed call. Skip rather than throw,
+                // matching the early-outs and the identical guard
+                // in RAGPipeline.ingestImages — the two entry points are independent
+                // (prepareRAGTool builds its chunks here, not via ingestImages), so
+                // each needs its own.
+                if (imageDoc.mimeType === "image/svg+xml" ||
+                    ImageProcessor.detectImageType(imageDoc.image) === "image/svg+xml") {
+                    logger.warn(`[RAG] SVG is not supported as a RAG image source, skipping: ${redactUrlForError(imgPath)}`);
+                    continue;
+                }
                 // Use filename-based text representation for simple embedding
                 const imageText = imageDoc.text;
                 imageChunks.push({
@@ -476,7 +496,7 @@ async function _prepareRAGToolInner(ragConfig, fallbackProvider) {
         tool: aiTool,
         toolName,
         chunksIndexed: allChunks.length + imageChunks.length,
-        filesLoaded: fileContents.length + imageFiles.length,
+        filesLoaded: fileContents.length + imageChunks.length,
     };
 }
 /** @internal Exported for testing only */

package/dist/types/file.d.ts

@@ -9,6 +9,16 @@ export type FileType = "csv" | "image" | "pdf" | "audio" | "video" | "archive" |
  * Office document types
  */
 export type OfficeDocumentType = "docx" | "pptx" | "xlsx";
+/**
+ * Transcode target for a vision-incompatible image (`adapters/imageFormatSupport.ts`).
+ *
+ * Defaults to `"png"` everywhere a caller does not pick one: sources routed
+ * through that module are frequently lossless (TIFF, BMP, ICO) or already
+ * carry alpha, and a lossy re-encode of an image the model is about to read
+ * closely is the wrong default. `"jpeg"` is available for callers who know
+ * their source has no alpha and prefer the smaller payload.
+ */
+export type VisionImageOutputFormat = "png" | "jpeg";
 /**
  * Outcome of a vision-compatibility pass over one image.
  *

package/dist/types/generate.d.ts

@@ -17,7 +17,7 @@ import type { AvatarOptions, AvatarResult } from "./avatar.js";
 import type { MusicOptions, MusicResult } from "./music.js";
 import type { StandardRecord, ValidationSchema, ZodUnknownSchema } from "./aliases.js";
 import type { NeurolinkCredentials } from "./providers.js";
-import type { CSVProcessorOptions, FileWithMetadata, MultimodalAudioEntry } from "./file.js";
+import type { CSVProcessorOptions, FileWithMetadata, MultimodalAudioEntry, VisionImageOutputFormat } from "./file.js";
 import type { WorkflowConfig } from "./workflow.js";
 import type { Schema, Tool, ToolChoice } from "./tools.js";
 import type { StepResult, LanguageModel } from "./providers.js";
@@ -156,6 +156,18 @@ export type GenerateOptions = {
          */
         maxPages?: number;
     };
+    /**
+     * Options for images that need transcoding before a vision provider can
+     * read them (HEIC, TIFF, BMP, ICO, JPEG 2000, AVIF — see
+     * `adapters/imageFormatSupport.ts`).
+     */
+    imageOptions?: {
+        /**
+         * Transcode target for an incompatible image. Defaults to `"png"` — the
+         * module's own default, unchanged unless a caller opts in here.
+         */
+        outputFormat?: VisionImageOutputFormat;
+    };
     videoOptions?: {
         /** Frames to extract. Unset lets VideoProcessor pick from the clip's duration; clamped to 100. */
         frames?: number;
@@ -1394,6 +1406,20 @@ export type TextGenerationOptions = {
         /** Max pages converted by the image fallback (#297); defaults to PDF_LIMITS.DEFAULT_MAX_PAGES. */
         maxPages?: number;
     };
+    /**
+     * Options for images that need transcoding before a vision provider can
+     * read them (HEIC, TIFF, BMP, ICO, JPEG 2000, AVIF — see
+     * `adapters/imageFormatSupport.ts`). Mirrors `GenerateOptions.imageOptions`;
+     * this is the shape that actually reaches `MessageBuilder` for providers
+     * built on `BaseProvider`.
+     */
+    imageOptions?: {
+        /**
+         * Transcode target for an incompatible image. Defaults to `"png"` — the
+         * module's own default, unchanged unless a caller opts in here.
+         */
+        outputFormat?: VisionImageOutputFormat;
+    };
     enableSummarization?: boolean;
     /**
      * Skip injecting tool schemas into the system prompt.

package/dist/types/stream.d.ts

@@ -15,7 +15,7 @@ import type { AIModelProviderConfig, NeurolinkCredentials } from "./providers.js
 import type { TTSChunk, TTSOptions, TTSResult } from "./tts.js";
 import type { STTOptions, STTResult } from "./stt.js";
 import type { StandardRecord, ValidationSchema } from "./aliases.js";
-import type { CSVProcessorOptions, FileWithMetadata } from "./file.js";
+import type { CSVProcessorOptions, FileWithMetadata, VisionImageOutputFormat } from "./file.js";
 import type { WorkflowConfig } from "./workflow.js";
 import type { LanguageModel, StepResult } from "./providers.js";
 import type { Tool, ToolChoice } from "./tools.js";
@@ -373,6 +373,18 @@ export type StreamOptions = {
          */
         maxPages?: number;
     };
+    /**
+     * Options for images that need transcoding before a vision provider can
+     * read them (HEIC, TIFF, BMP, ICO, JPEG 2000, AVIF — see
+     * `adapters/imageFormatSupport.ts`). Mirrors `GenerateOptions.imageOptions`.
+     */
+    imageOptions?: {
+        /**
+         * Transcode target for an incompatible image. Defaults to `"png"` — the
+         * module's own default, unchanged unless a caller opts in here.
+         */
+        outputFormat?: VisionImageOutputFormat;
+    };
     videoOptions?: {
         /** Frames to extract. Unset lets VideoProcessor pick from the clip's duration; clamped to 100. */
         frames?: number;

package/dist/utils/imageProcessor.js

@@ -65,6 +65,153 @@ const RETRYABLE_ERROR_CODES = new Set([
     "ETIMEDOUT",
     "ERR_NETWORK",
 ]);
+/**
+ * Bytes of prologue {@link hasSvgRoot} decodes and scans.
+ *
+ * A real SVG reaches its root within a few hundred bytes, so 4KB is generous.
+ * The cap exists because scanning the whole buffer made every unrecognized
+ * binary — and every BMP/TIFF/ICO/AVIF, whose checks run after this one — pay
+ * a full UTF-8 decode, and let a crafted unterminated doctype walk every byte
+ * (measured: 322ms on 32MB, 69ms to reject a 16MB BMP).
+ */
+const SVG_PROLOGUE_SCAN_BYTES = 4096;
+/**
+ * Find an SVG root after XML's permitted leading constructs.
+ *
+ * Deliberately a discriminator, not an XML parser. Raster magic is checked
+ * first; this only distinguishes text reaching an SVG root after a UTF-8 BOM,
+ * XML whitespace, processing instructions, comments, or a doctype. The doctype
+ * scanner tracks quotes, comments/PIs, and the internal subset so a `>` or
+ * `]` inside any of them cannot expose a later `<svg` early. The root itself
+ * may carry an XML namespace prefix (`<s:svg xmlns:s="...">`), which is
+ * accepted alongside the bare `<svg` form.
+ *
+ * Scanning a bounded window makes "unterminated" ambiguous, and the two cases
+ * must resolve OPPOSITE ways:
+ *
+ *  - the WINDOW ran out — the rest of the document is unreadable from here, so
+ *    fail CLOSED and answer SVG. This function gates a rejection, so answering
+ *    raster on an unterminated prologue would hand back the exact bypass it
+ *    exists to close: prepend filler past the window and sail through as
+ *    raster. A raster file never opens `<!--` or `<!doctype`, so the
+ *    false-positive cost is a skipped image; the other direction is the
+ *    vulnerability.
+ *  - the BUFFER ran out — the whole document was read and is malformed, so it
+ *    is genuinely not an SVG.
+ */
+function hasSvgRoot(input) {
+    const windowed = input.length > SVG_PROLOGUE_SCAN_BYTES;
+    const text = input
+        .subarray(0, Math.min(input.length, SVG_PROLOGUE_SCAN_BYTES))
+        .toString("utf8");
+    let position = text.charCodeAt(0) === 0xfeff ? 1 : 0;
+    const skipWhitespace = () => {
+        while (/\s/.test(text[position] ?? "")) {
+            position++;
+        }
+    };
+    const skipDoctype = () => {
+        let quote;
+        let subsetDepth = 0;
+        let index = position + 9;
+        while (index < text.length) {
+            const char = text[index];
+            if (quote) {
+                if (char === quote) {
+                    quote = undefined;
+                }
+                index++;
+                continue;
+            }
+            // Comments and processing instructions are valid markup inside the
+            // internal subset (and, leniently, anywhere else in the declaration)
+            // and may themselves contain `]` or `>` — e.g. `<!-- ] > -->`. Skip
+            // them as opaque spans, the same way the outer scan does, so their
+            // contents can never be misread as the subset-close or doctype-end
+            // delimiter.
+            if (text.startsWith("<!--", index)) {
+                const end = text.indexOf("-->", index + 4);
+                if (end < 0) {
+                    return false;
+                }
+                index = end + 3;
+                continue;
+            }
+            if (text.startsWith("<?", index)) {
+                const end = text.indexOf("?>", index + 2);
+                if (end < 0) {
+                    return false;
+                }
+                index = end + 2;
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                quote = char;
+            }
+            else if (char === "[") {
+                subsetDepth++;
+            }
+            else if (char === "]" && subsetDepth > 0) {
+                subsetDepth--;
+            }
+            else if (char === ">" && subsetDepth === 0) {
+                position = index + 1;
+                return true;
+            }
+            index++;
+        }
+        return false;
+    };
+    skipWhitespace();
+    while (position < text.length) {
+        if (text.startsWith("<?", position)) {
+            const end = text.indexOf("?>", position + 2);
+            if (end < 0) {
+                return windowed;
+            }
+            position = end + 2;
+        }
+        else if (text.startsWith("<!--", position)) {
+            const end = text.indexOf("-->", position + 4);
+            if (end < 0) {
+                return windowed;
+            }
+            position = end + 3;
+        }
+        else if (text.slice(position, position + 9).toLowerCase() === "<!doctype") {
+            if (!skipDoctype()) {
+                return windowed;
+            }
+        }
+        else {
+            break;
+        }
+        skipWhitespace();
+    }
+    const rest = text.slice(position);
+    // Accepts an optional XML namespace prefix ahead of the tag name — an
+    // NCName (letters/digits/`.`/`-`/`_`, not starting with a digit) followed
+    // by `:` — so `<s:svg xmlns:s="...">` matches the same way bare `<svg`
+    // does.
+    if (/^<(?:[A-Za-z_][\w.-]*:)?svg(?:[\s/>])/i.test(rest)) {
+        return true;
+    }
+    // A fixed "`<svg` plus its delimiter is 5 characters" cutoff only worked
+    // when the tag name was the literal `svg`. With a namespace prefix now
+    // accepted, the prefix is unbounded (any NCName), so no fixed length can
+    // bound "may still be mid-token" — `<s:svg` (6 chars) is just as
+    // truncatable as `<svg` (4) was. Instead, check whether `rest` could still
+    // be the START of a string this function would accept: an optional NCName
+    // prefix, optionally followed by `:` and however much of the literal
+    // `svg` has been seen so far, with nothing left over. Anything left over
+    // (a character that cannot continue the prefix, isn't `:`, or doesn't
+    // continue "svg") proves `rest` can never complete into a match, so it is
+    // safe to answer false even though the window is cut. An empty `rest` is
+    // the same ambiguity in the degenerate case (no root text observed yet).
+    const isUnresolvedPrefix = rest.length === 0 ||
+        /^<(?:[A-Za-z_][\w.-]*)?(?::(?:s(?:v(?:g)?)?)?)?$/i.test(rest);
+    return windowed && isUnresolvedPrefix;
+}
 /**
  * Determines if an HTTP error is retryable based on status code
  * Only network errors and certain HTTP status codes should be retried
@@ -452,12 +599,10 @@ export class ImageProcessor {
                         return "image/webp";
                     }
                 }
-                // SVG: check for "<svg" or "<?xml" at start (text-based)
-                if (input.length >= 4) {
-                    const start = input.subarray(0, 4).toString();
-                    if (start === "<svg" || start === "<?xm") {
-                        return "image/svg+xml";
-                    }
+                // SVG is text-based and may legally put a BOM, whitespace, an XML
+                // declaration, comments, or a doctype before its root element.
+                if (hasSvgRoot(input)) {
+                    return "image/svg+xml";
                 }
                 // ISO-BMFF images: "ftyp" box at offset 4, major brand at offset 8.
                 // AVIF has codec-specific major brands. HEIC uses HEVC image/sequence

package/dist/utils/messageBuilder.d.ts

@@ -1,4 +1,4 @@
-import type { GenerateOptions, MultimodalChatMessage, StreamOptions, TextGenerationOptions } from "../types/index.js";
+import type { GenerateOptions, MultimodalChatMessage, StreamOptions, TextGenerationOptions, VisionImageOutputFormat } from "../types/index.js";
 import type { ModelMessage } from "../types/index.js";
 /**
  * Type-safe conversion from MultimodalChatMessage[] to ModelMessage[]
@@ -56,4 +56,4 @@ export declare function buildMultimodalMessagesArray(options: GenerateOptions, p
  * Entries that are `http(s)` URLs are left alone — they have no bytes yet, and
  * `processImageToBase64` converts them once they are downloaded.
  */
-export declare function normalizeVisionImageFormats(input: GenerateOptions["input"]): Promise<void>;
+export declare function normalizeVisionImageFormats(input: GenerateOptions["input"], outputFormat?: VisionImageOutputFormat): Promise<void>;

package/dist/utils/messageBuilder.js

@@ -1352,7 +1352,7 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     await processUnifiedFilesArray(options, maxSize, provider);
     // Detection can append images (PDF page renders, video keyframes, a HEIC
     // photo), so compatibility conversion has to run after it, not before.
-    await normalizeVisionImageFormats(inp);
+    await normalizeVisionImageFormats(inp, options.imageOptions?.outputFormat);
     // Process explicit CSV files array
     await processExplicitCsvFiles(options);
     // Post-processing budget enforcement and token usage logging
@@ -1486,7 +1486,7 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
             // the multimodal converter below, so the bytes were dropped and only the
             // metadata summary folded into `text` survived. Exactly the failure this
             // change exists to remove, reintroduced through the other door.
-            userContent = await convertContentToProviderFormat(inp.content, provider, model, options.pdfOptions, inp.nativeAudioFiles ?? []);
+            userContent = await convertContentToProviderFormat(inp.content, provider, model, options.pdfOptions, inp.nativeAudioFiles ?? [], options.imageOptions?.outputFormat);
         }
         else if ((inp.images && inp.images.length > 0) ||
             pdfFiles.length > 0 ||
@@ -1495,7 +1495,10 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
             // recording was dropped and only its metadata summary — already folded
             // into `text` — ever reached the model.
             (inp.nativeAudioFiles?.length ?? 0) > 0) {
-            userContent = await convertMultimodalToProviderFormat(inp.text ?? "", inp.images || [], pdfFiles, provider, model, inp.nativeAudioFiles ?? []);
+            userContent = await convertMultimodalToProviderFormat(inp.text ?? "", inp.images || [], pdfFiles, provider, model, {
+                audioFiles: inp.nativeAudioFiles ?? [],
+                outputFormat: options.imageOptions?.outputFormat,
+            });
         }
         else {
             userContent = inp.text;
@@ -1571,7 +1574,7 @@ async function appendCsvContentToText(csvItems, baseText) {
 /**
  * Convert advanced content format to provider-specific format
  */
-async function convertContentToProviderFormat(content, provider, _model, pdfOptions, audioFiles = []) {
+async function convertContentToProviderFormat(content, provider, _model, pdfOptions, audioFiles = [], outputFormat) {
     const textContent = content.find((c) => c.type === "text");
     const imageContent = content.filter((c) => c.type === "image");
     const pdfContent = content.filter((c) => c.type === "pdf");
@@ -1624,7 +1627,10 @@ async function convertContentToProviderFormat(content, provider, _model, pdfOpti
     await enforceAggregatePdfLimits(pdfFiles, provider, {
         trustSuppliedPageCounts: false,
     });
-    return await convertMultimodalToProviderFormat(text, images, pdfFiles, provider, _model, audioFiles);
+    return await convertMultimodalToProviderFormat(text, images, pdfFiles, provider, _model, {
+        audioFiles,
+        outputFormat,
+    });
 }
 /**
  * Check if a string is an internet URL
@@ -1868,7 +1874,7 @@ async function convertFilePathToBase64(filePath) {
  * Passing raw base64 avoids this because `new URL(base64string)` throws and
  * the SDK treats the string as inline base64 data instead.
  */
-async function processImageToBase64(image, index) {
+async function processImageToBase64(image, index, outputFormat) {
     let imageData;
     let mimeType = "image/jpeg"; // Default mime type
     if (typeof image === "string") {
@@ -1947,7 +1953,7 @@ async function processImageToBase64(image, index) {
         const context = `image input at index ${index}`;
         ImageProcessor.validateSize(base64DecodedByteLength(imageData), context);
         const rawImage = Buffer.from(imageData, "base64");
-        const compatible = await toVisionCompatibleImage(rawImage, mimeType);
+        const compatible = await toVisionCompatibleImage(rawImage, mimeType, outputFormat);
         if (compatible.converted) {
             imageData = compatible.buffer.toString("base64");
             mimeType = compatible.mimeType;
@@ -1968,7 +1974,7 @@ async function processImageToBase64(image, index) {
  * Entries that are `http(s)` URLs are left alone — they have no bytes yet, and
  * `processImageToBase64` converts them once they are downloaded.
  */
-export async function normalizeVisionImageFormats(input) {
+export async function normalizeVisionImageFormats(input, outputFormat) {
     const images = input?.images;
     if (!images || images.length === 0) {
         return;
@@ -1985,7 +1991,7 @@ export async function normalizeVisionImageFormats(input) {
         if (!source || !needsVisionTranscode(source.mimeType)) {
             continue;
         }
-        const compatible = await toVisionCompatibleImage(source.buffer, source.mimeType);
+        const compatible = await toVisionCompatibleImage(source.buffer, source.mimeType, outputFormat);
         if (!compatible.converted) {
             continue;
         }
@@ -2115,7 +2121,7 @@ async function readImageSourceForConversion(payload) {
  * - Buffers/Data URIs: Processed normally
  * - Supports alt text for accessibility (included as context in text parts)
  */
-async function convertSimpleImagesToProviderFormat(text, images, provider, _model) {
+async function convertSimpleImagesToProviderFormat(text, images, provider, _model, outputFormat) {
     // Validate image count against provider-specific limits before processing
     ProviderImageAdapter.validateImageCount(images.length, provider, _model);
     // For Vercel AI SDK, we need to return the content in the standard format
@@ -2172,7 +2178,7 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
     for (const [index, { data: image }] of actualImages.entries()) {
         try {
             // Use helper function to process image and reduce nesting depth
-            const { imageData, mimeType } = await processImageToBase64(image, index);
+            const { imageData, mimeType } = await processImageToBase64(image, index, outputFormat);
             content.push({
                 type: "image",
                 image: imageData,
@@ -2195,13 +2201,17 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
 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, audioFiles = []) {
+pdfFiles, provider, model, 
+// Bundled rather than two more positional params: a 7th would trip the
+// repo's `max-params` ceiling of 6.
+mediaOptions = {}) {
+    const { audioFiles = [], outputFormat } = mediaOptions;
     const content = [
         { type: "text", text },
     ];
     // Add images if present
     if (images.length > 0) {
-        const imageContent = await convertSimpleImagesToProviderFormat("", images, provider, model);
+        const imageContent = await convertSimpleImagesToProviderFormat("", images, provider, model, outputFormat);
         if (Array.isArray(imageContent)) {
             imageContent.forEach((item) => {
                 if (item.type !== "text") {

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -61,6 +61,9 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
         scale?: number;
         maxPages?: number;
     } | undefined;
+    imageOptions: {
+        outputFormat?: import("../index.js").VisionImageOutputFormat;
+    } | undefined;
     systemPrompt: string | undefined;
     conversationHistory: import("../index.js").ChatMessage[] | undefined;
     provider: string;

package/dist/utils/multimodalOptionsBuilder.js

@@ -59,6 +59,7 @@ export function buildMultimodalOptions(options, providerName, modelName) {
         },
         csvOptions: options.csvOptions,
         pdfOptions: options.pdfOptions,
+        imageOptions: options.imageOptions,
         systemPrompt: options.systemPrompt,
         conversationHistory: options.conversationMessages,
         provider: providerName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.19.2",
+  "version": "12.20.0",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -242,6 +242,7 @@
     "test:mcp-result-cache": "pnpm exec tsx test/continuous-test-suite-mcp-result-cache.ts",
     "test:archive:security": "pnpm exec tsx test/continuous-test-suite-archive-security.ts",
     "test:office:security": "pnpm exec tsx test/continuous-test-suite-office-security.ts",
+    "test:vision-image-format": "pnpm exec tsx test/continuous-test-suite-vision-image-format.ts",
     "test:model-pool": "pnpm exec tsx test/continuous-test-suite-model-pool.ts",
     "test:agents": "pnpm exec tsx test/continuous-test-suite-agents.ts",
     "test:classifier-router": "pnpm exec tsx test/continuous-test-suite-classifier-router.ts",