@juspay/neurolink 9.49.0 → 9.50.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [9.50.0](https://github.com/juspay/neurolink/compare/v9.49.0...v9.50.0) (2026-04-08)
+
+### Features
+
+- **(image-compression):** add sharp-based compression for AI providers ([75645bf](https://github.com/juspay/neurolink/commit/75645bf69d9eb21bf46763c5b058cb92146c71f2)), closes [#553](https://github.com/juspay/neurolink/issues/553)
+
 ## [9.49.0](https://github.com/juspay/neurolink/compare/v9.48.3...v9.49.0) (2026-04-08)
 
 ### Features

package/dist/lib/utils/imageCompressor.d.ts

@@ -0,0 +1,45 @@
+import type { ProviderName } from "../types/providers.js";
+declare const SUPPORTED_FORMATS: readonly ["jpeg", "png", "webp"];
+type SupportedFormat = (typeof SUPPORTED_FORMATS)[number];
+/**
+ * Provider-specific image size limits in bytes
+ */
+export declare const PROVIDER_IMAGE_LIMITS: Record<ProviderName, number>;
+export interface CompressionOptions {
+    provider: ProviderName;
+    quality?: number;
+    maxDimension?: number;
+    format?: SupportedFormat;
+}
+export interface CompressionResult {
+    buffer: Buffer;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    metadata: {
+        width: number;
+        height: number;
+        format: string;
+    };
+}
+/**
+ * Compress an image to meet provider-specific size limits
+ * @param imageBuffer - Input image buffer
+ * @param options - Compression options including provider name
+ * @returns Compressed image buffer with metadata
+ */
+export declare function compressImage(imageBuffer: Buffer, options: CompressionOptions): Promise<CompressionResult>;
+/**
+ * Check if an image needs compression for a specific provider
+ * @param imageBuffer - Input image buffer
+ * @param provider - AI provider name
+ * @returns True if compression is needed
+ */
+export declare function needsCompression(imageBuffer: Buffer, provider: ProviderName): boolean;
+/**
+ * Get the size limit for a specific provider
+ * @param provider - AI provider name
+ * @returns Size limit in bytes
+ */
+export declare function getProviderSizeLimit(provider: ProviderName): number;
+export {};

package/dist/lib/utils/imageCompressor.js

@@ -0,0 +1,137 @@
+import sharp from "sharp";
+import { withTimeout } from "./async/index.js";
+const SUPPORTED_FORMATS = ["jpeg", "png", "webp"];
+const IMAGE_COMPRESSION_TIMEOUT_MS = 30_000;
+/**
+ * Provider-specific image size limits in bytes
+ */
+export const PROVIDER_IMAGE_LIMITS = {
+    openai: 20 * 1024 * 1024, // 20MB
+    "openai-compatible": 20 * 1024 * 1024, // 20MB (same as OpenAI)
+    anthropic: 5 * 1024 * 1024, // 5MB
+    "google-ai": 4 * 1024 * 1024, // 4MB
+    vertex: 4 * 1024 * 1024, // 4MB
+    bedrock: 5 * 1024 * 1024, // 5MB
+    azure: 20 * 1024 * 1024, // 20MB
+    mistral: 5 * 1024 * 1024, // 5MB
+    huggingface: 10 * 1024 * 1024, // 10MB
+    ollama: 100 * 1024 * 1024, // 100MB (local, no strict limit)
+    openrouter: 20 * 1024 * 1024, // 20MB
+    sagemaker: 5 * 1024 * 1024, // 5MB
+    litellm: 20 * 1024 * 1024, // 20MB (proxy, use OpenAI default)
+    auto: 5 * 1024 * 1024, // 5MB (conservative fallback)
+};
+/**
+ * Compress an image to meet provider-specific size limits
+ * @param imageBuffer - Input image buffer
+ * @param options - Compression options including provider name
+ * @returns Compressed image buffer with metadata
+ */
+export async function compressImage(imageBuffer, options) {
+    const { provider, quality = 80, maxDimension, format } = options;
+    const sizeLimit = PROVIDER_IMAGE_LIMITS[provider];
+    const originalSize = imageBuffer.length;
+    // Get original metadata
+    const image = sharp(imageBuffer);
+    const metadata = await withTimeout(image.metadata(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out reading image metadata");
+    if (!metadata.width || !metadata.height) {
+        throw new Error("Unable to read image dimensions");
+    }
+    // If image is already under limit and no format conversion needed, return as-is
+    if (originalSize <= sizeLimit && !format && !maxDimension) {
+        return {
+            buffer: imageBuffer,
+            originalSize,
+            compressedSize: originalSize,
+            compressionRatio: 1,
+            metadata: {
+                width: metadata.width,
+                height: metadata.height,
+                format: metadata.format ?? "unknown",
+            },
+        };
+    }
+    // Prepare compression pipeline
+    let pipeline = sharp(imageBuffer);
+    // Resize if needed
+    if (maxDimension) {
+        const needsResize = metadata.width > maxDimension || metadata.height > maxDimension;
+        if (needsResize) {
+            pipeline = pipeline.resize(maxDimension, maxDimension, {
+                fit: "inside",
+                withoutEnlargement: true,
+            });
+        }
+    }
+    // Resolve target format — validate metadata.format against supported set
+    const rawFormat = metadata.format;
+    const targetFormat = format ??
+        (SUPPORTED_FORMATS.includes(rawFormat)
+            ? rawFormat
+            : "jpeg");
+    const applyFormat = (p, q) => {
+        switch (targetFormat) {
+            case "jpeg":
+                return p.jpeg({ quality: q, mozjpeg: true });
+            case "png":
+                return p.png({ quality: q, compressionLevel: 9 });
+            case "webp":
+                return p.webp({ quality: q });
+        }
+    };
+    // Compress
+    let compressedBuffer = await withTimeout(applyFormat(pipeline, quality).toBuffer(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out compressing image");
+    let currentQuality = quality;
+    // Iteratively reduce quality if still over limit
+    // Note: the sharp pipeline must be rebuilt on each iteration because
+    // sharp does not support modifying quality settings after creation.
+    while (compressedBuffer.length > sizeLimit && currentQuality > 10) {
+        currentQuality -= 10;
+        let p = sharp(imageBuffer);
+        if (maxDimension) {
+            p = p.resize(maxDimension, maxDimension, {
+                fit: "inside",
+                withoutEnlargement: true,
+            });
+        }
+        compressedBuffer = await withTimeout(applyFormat(p, currentQuality).toBuffer(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out compressing image");
+    }
+    // Final check
+    if (compressedBuffer.length > sizeLimit) {
+        throw new Error(`Unable to compress image to ${sizeLimit} bytes for provider ${provider}. ` +
+            `Final size: ${compressedBuffer.length} bytes. ` +
+            `Try using a smaller image or lower maxDimension.`);
+    }
+    // Get final metadata
+    const finalMetadata = await withTimeout(sharp(compressedBuffer).metadata(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out reading compressed image metadata");
+    return {
+        buffer: compressedBuffer,
+        originalSize,
+        compressedSize: compressedBuffer.length,
+        compressionRatio: originalSize / compressedBuffer.length,
+        metadata: {
+            width: finalMetadata.width ?? 0,
+            height: finalMetadata.height ?? 0,
+            format: targetFormat,
+        },
+    };
+}
+/**
+ * Check if an image needs compression for a specific provider
+ * @param imageBuffer - Input image buffer
+ * @param provider - AI provider name
+ * @returns True if compression is needed
+ */
+export function needsCompression(imageBuffer, provider) {
+    const sizeLimit = PROVIDER_IMAGE_LIMITS[provider];
+    return imageBuffer.length > sizeLimit;
+}
+/**
+ * Get the size limit for a specific provider
+ * @param provider - AI provider name
+ * @returns Size limit in bytes
+ */
+export function getProviderSizeLimit(provider) {
+    return PROVIDER_IMAGE_LIMITS[provider];
+}
+//# sourceMappingURL=imageCompressor.js.map

package/dist/utils/imageCompressor.d.ts

@@ -0,0 +1,45 @@
+import type { ProviderName } from "../types/providers.js";
+declare const SUPPORTED_FORMATS: readonly ["jpeg", "png", "webp"];
+type SupportedFormat = (typeof SUPPORTED_FORMATS)[number];
+/**
+ * Provider-specific image size limits in bytes
+ */
+export declare const PROVIDER_IMAGE_LIMITS: Record<ProviderName, number>;
+export interface CompressionOptions {
+    provider: ProviderName;
+    quality?: number;
+    maxDimension?: number;
+    format?: SupportedFormat;
+}
+export interface CompressionResult {
+    buffer: Buffer;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    metadata: {
+        width: number;
+        height: number;
+        format: string;
+    };
+}
+/**
+ * Compress an image to meet provider-specific size limits
+ * @param imageBuffer - Input image buffer
+ * @param options - Compression options including provider name
+ * @returns Compressed image buffer with metadata
+ */
+export declare function compressImage(imageBuffer: Buffer, options: CompressionOptions): Promise<CompressionResult>;
+/**
+ * Check if an image needs compression for a specific provider
+ * @param imageBuffer - Input image buffer
+ * @param provider - AI provider name
+ * @returns True if compression is needed
+ */
+export declare function needsCompression(imageBuffer: Buffer, provider: ProviderName): boolean;
+/**
+ * Get the size limit for a specific provider
+ * @param provider - AI provider name
+ * @returns Size limit in bytes
+ */
+export declare function getProviderSizeLimit(provider: ProviderName): number;
+export {};

package/dist/utils/imageCompressor.js

@@ -0,0 +1,136 @@
+import sharp from "sharp";
+import { withTimeout } from "./async/index.js";
+const SUPPORTED_FORMATS = ["jpeg", "png", "webp"];
+const IMAGE_COMPRESSION_TIMEOUT_MS = 30_000;
+/**
+ * Provider-specific image size limits in bytes
+ */
+export const PROVIDER_IMAGE_LIMITS = {
+    openai: 20 * 1024 * 1024, // 20MB
+    "openai-compatible": 20 * 1024 * 1024, // 20MB (same as OpenAI)
+    anthropic: 5 * 1024 * 1024, // 5MB
+    "google-ai": 4 * 1024 * 1024, // 4MB
+    vertex: 4 * 1024 * 1024, // 4MB
+    bedrock: 5 * 1024 * 1024, // 5MB
+    azure: 20 * 1024 * 1024, // 20MB
+    mistral: 5 * 1024 * 1024, // 5MB
+    huggingface: 10 * 1024 * 1024, // 10MB
+    ollama: 100 * 1024 * 1024, // 100MB (local, no strict limit)
+    openrouter: 20 * 1024 * 1024, // 20MB
+    sagemaker: 5 * 1024 * 1024, // 5MB
+    litellm: 20 * 1024 * 1024, // 20MB (proxy, use OpenAI default)
+    auto: 5 * 1024 * 1024, // 5MB (conservative fallback)
+};
+/**
+ * Compress an image to meet provider-specific size limits
+ * @param imageBuffer - Input image buffer
+ * @param options - Compression options including provider name
+ * @returns Compressed image buffer with metadata
+ */
+export async function compressImage(imageBuffer, options) {
+    const { provider, quality = 80, maxDimension, format } = options;
+    const sizeLimit = PROVIDER_IMAGE_LIMITS[provider];
+    const originalSize = imageBuffer.length;
+    // Get original metadata
+    const image = sharp(imageBuffer);
+    const metadata = await withTimeout(image.metadata(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out reading image metadata");
+    if (!metadata.width || !metadata.height) {
+        throw new Error("Unable to read image dimensions");
+    }
+    // If image is already under limit and no format conversion needed, return as-is
+    if (originalSize <= sizeLimit && !format && !maxDimension) {
+        return {
+            buffer: imageBuffer,
+            originalSize,
+            compressedSize: originalSize,
+            compressionRatio: 1,
+            metadata: {
+                width: metadata.width,
+                height: metadata.height,
+                format: metadata.format ?? "unknown",
+            },
+        };
+    }
+    // Prepare compression pipeline
+    let pipeline = sharp(imageBuffer);
+    // Resize if needed
+    if (maxDimension) {
+        const needsResize = metadata.width > maxDimension || metadata.height > maxDimension;
+        if (needsResize) {
+            pipeline = pipeline.resize(maxDimension, maxDimension, {
+                fit: "inside",
+                withoutEnlargement: true,
+            });
+        }
+    }
+    // Resolve target format — validate metadata.format against supported set
+    const rawFormat = metadata.format;
+    const targetFormat = format ??
+        (SUPPORTED_FORMATS.includes(rawFormat)
+            ? rawFormat
+            : "jpeg");
+    const applyFormat = (p, q) => {
+        switch (targetFormat) {
+            case "jpeg":
+                return p.jpeg({ quality: q, mozjpeg: true });
+            case "png":
+                return p.png({ quality: q, compressionLevel: 9 });
+            case "webp":
+                return p.webp({ quality: q });
+        }
+    };
+    // Compress
+    let compressedBuffer = await withTimeout(applyFormat(pipeline, quality).toBuffer(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out compressing image");
+    let currentQuality = quality;
+    // Iteratively reduce quality if still over limit
+    // Note: the sharp pipeline must be rebuilt on each iteration because
+    // sharp does not support modifying quality settings after creation.
+    while (compressedBuffer.length > sizeLimit && currentQuality > 10) {
+        currentQuality -= 10;
+        let p = sharp(imageBuffer);
+        if (maxDimension) {
+            p = p.resize(maxDimension, maxDimension, {
+                fit: "inside",
+                withoutEnlargement: true,
+            });
+        }
+        compressedBuffer = await withTimeout(applyFormat(p, currentQuality).toBuffer(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out compressing image");
+    }
+    // Final check
+    if (compressedBuffer.length > sizeLimit) {
+        throw new Error(`Unable to compress image to ${sizeLimit} bytes for provider ${provider}. ` +
+            `Final size: ${compressedBuffer.length} bytes. ` +
+            `Try using a smaller image or lower maxDimension.`);
+    }
+    // Get final metadata
+    const finalMetadata = await withTimeout(sharp(compressedBuffer).metadata(), IMAGE_COMPRESSION_TIMEOUT_MS, "Timed out reading compressed image metadata");
+    return {
+        buffer: compressedBuffer,
+        originalSize,
+        compressedSize: compressedBuffer.length,
+        compressionRatio: originalSize / compressedBuffer.length,
+        metadata: {
+            width: finalMetadata.width ?? 0,
+            height: finalMetadata.height ?? 0,
+            format: targetFormat,
+        },
+    };
+}
+/**
+ * Check if an image needs compression for a specific provider
+ * @param imageBuffer - Input image buffer
+ * @param provider - AI provider name
+ * @returns True if compression is needed
+ */
+export function needsCompression(imageBuffer, provider) {
+    const sizeLimit = PROVIDER_IMAGE_LIMITS[provider];
+    return imageBuffer.length > sizeLimit;
+}
+/**
+ * Get the size limit for a specific provider
+ * @param provider - AI provider name
+ * @returns Size limit in bytes
+ */
+export function getProviderSizeLimit(provider) {
+    return PROVIDER_IMAGE_LIMITS[provider];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.49.0",
+  "version": "9.50.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {