@juspay/neurolink 8.35.2 → 8.37.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [8.37.0](https://github.com/juspay/neurolink/compare/v8.36.0...v8.37.0) (2026-01-22)
+
+### Features
+
+- **(security):** Implement token bucket rate limiter for URL downloads ([0e3e779](https://github.com/juspay/neurolink/commit/0e3e7797800360ab1672fcb8fbd87b1f794b6e1a))
+
+## [8.36.0](https://github.com/juspay/neurolink/compare/v8.35.2...v8.36.0) (2026-01-22)
+
+### Features
+
+- **(ppt):** Add Types and Validation for PPT generation ([27b970c](https://github.com/juspay/neurolink/commit/27b970c9fd5d74161b74603738ca307f8217e287))
+
 ## [8.35.2](https://github.com/juspay/neurolink/compare/v8.35.1...v8.35.2) (2026-01-15)
 
 ### Bug Fixes

package/dist/lib/types/generateTypes.d.ts

@@ -8,6 +8,7 @@ import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 import type { JsonValue } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { TTSOptions, TTSResult } from "./ttsTypes.js";
+import type { PPTOutputOptions, PPTGenerationResult } from "./pptTypes.js";
 import type { VideoOutputOptions, VideoGenerationResult } from "./multimodal.js";
 /**
  * Generate function options type - Primary method for content generation
@@ -68,13 +69,19 @@ export type GenerateOptions = {
          * Output mode - determines the type of content generated
          * - "text": Standard text generation (default)
          * - "video": Video generation using models like Veo 3.1
+         * - "ppt": PowerPoint presentation generation
          */
-        mode?: "text" | "video";
+        mode?: "text" | "video" | "ppt";
         /**
          * Video generation configuration (used when mode is "video")
          * Requires an input image and text prompt
          */
         video?: VideoOutputOptions;
+        /**
+         * PowerPoint generation configuration (used when mode is "ppt")
+         * Generates slides based on text prompt
+         */
+        ppt?: PPTOutputOptions;
     };
     csvOptions?: {
         maxRows?: number;
@@ -312,6 +319,24 @@ export type GenerateResult = {
      * ```
      */
     video?: VideoGenerationResult;
+    /**
+     * PowerPoint generation result (present when output.mode is "ppt")
+     *
+     * @example
+     * ```typescript
+     * const result = await neurolink.generate({
+     *   input: { text: "Introducing Our New Product" },
+     *   model: "gemini-pro",
+     *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+     * });
+     *
+     * if (result.ppt) {
+     *   console.log(`Generated ${result.ppt.slides.length} slides`);
+     *   console.log(`Title: ${result.ppt.slides[0].title}`);
+     * }
+     * ```
+     */
+    ppt?: PPTGenerationResult;
     imageOutput?: {
         base64: string;
     } | null;
@@ -434,12 +459,17 @@ export type TextGenerationOptions = {
          * Output mode - determines the type of content generated
          * - "text": Standard text generation (default)
          * - "video": Video generation using models like Veo 3.1
+         * - "ppt": PowerPoint presentation generation
          */
-        mode?: "text" | "video";
+        mode?: "text" | "video" | "ppt";
         /**
          * Video generation configuration (used when mode is "video")
          */
         video?: VideoOutputOptions;
+        /**
+         * PowerPoint generation configuration (used when mode is "ppt")
+         */
+        ppt?: PPTOutputOptions;
     };
     tools?: Record<string, Tool>;
     timeout?: number | string;
@@ -612,6 +642,8 @@ export type TextGenerationResult = {
     audio?: TTSResult;
     /** Video generation result */
     video?: VideoGenerationResult;
+    /** PowerPoint generation result */
+    ppt?: PPTGenerationResult;
     /** Image generation output */
     imageOutput?: {
         base64: string;

package/dist/lib/types/pptTypes.d.ts

@@ -0,0 +1,69 @@
+import type { ImageWithAltText } from "./content.js";
+type ThemeOption = "modern" | "corporate" | "creative" | "minimal" | "dark";
+type AudienceOption = "business" | "students" | "technical" | "general";
+type ToneOption = "professional" | "casual" | "educational" | "persuasive";
+type OutputFormatOption = "pptx";
+type AspectRatioOption = "16:9" | "4:3";
+export type PPTOutputOptions = {
+    /** Number of slides to generate (required, range: 5-50) */
+    pages: number;
+    /** Output format - only PPTX supported currently (default: "pptx") */
+    format?: OutputFormatOption;
+    /** Presentation theme/style (default: "modern") */
+    theme?: ThemeOption;
+    /** Target audience for content customization */
+    audience?: AudienceOption;
+    /** Presentation tone/style */
+    tone?: ToneOption;
+    /** Whether to generate AI images for slides (default: true) */
+    includeImages?: boolean;
+    /** Custom output file path (default: auto-generated in ./output/) */
+    outputPath?: string;
+    /** Aspect ratio for slides (default: "16:9") */
+    aspectRatio?: AspectRatioOption;
+    /** Path to logo image to include in slides */
+    logoPath?: Buffer | string | ImageWithAltText;
+};
+/**
+ * Result type for generated presentation content
+ *
+ * Returned in `GenerateResult.ppt` when presentation generation is successful.
+ * Contains the file path and metadata about the generated presentation.
+ *
+ * @example
+ * ```typescript
+ * const result = await neurolink.generate({
+ *   input: { text: "Introducing Our New Product" },
+ *   provider: "vertex",
+ *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+ * });
+ *
+ * if (result.ppt) {
+ *   console.log(`Presentation saved: ${result.ppt.filePath}`);
+ *   console.log(`Total slides: ${result.ppt.totalSlides}`);
+ *   console.log(`Theme: ${result.ppt.metadata?.theme}`);
+ * }
+ * ```
+ */
+export type PPTGenerationResult = {
+    /** Path to the generated PPTX file */
+    filePath: string;
+    /** Total number of slides in the presentation */
+    totalSlides: number;
+    /** Output format (always "pptx" currently) */
+    format: OutputFormatOption;
+    /** Presentation metadata */
+    metadata?: {
+        /** Theme/style used */
+        theme?: string;
+        /** Target audience */
+        audience?: string;
+        /** Presentation tone */
+        tone?: string;
+        /** Model used for image generation */
+        imageModel?: string;
+        /** File size in bytes */
+        fileSize?: number;
+    };
+};
+export {};

package/dist/lib/types/pptTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pptTypes.js.map

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

@@ -32,6 +32,18 @@ export declare const ERROR_CODES: {
     readonly IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
     readonly IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL";
     readonly INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT";
+    readonly RATE_LIMITER_QUEUE_FULL: "RATE_LIMITER_QUEUE_FULL";
+    readonly RATE_LIMITER_QUEUE_TIMEOUT: "RATE_LIMITER_QUEUE_TIMEOUT";
+    readonly RATE_LIMITER_RESET: "RATE_LIMITER_RESET";
+    readonly MISSING_PPT_PROPERTIES: "MISSING_PPT_PROPERTIES";
+    readonly INVALID_PPT_PAGES: "INVALID_PPT_PAGES";
+    readonly INVALID_PPT_FORMAT: "INVALID_PPT_FORMAT";
+    readonly INVALID_PPT_PROVIDER: "INVALID_PPT_PROVIDER";
+    readonly INVALID_PPT_OUTPUT_OPTIONS: "INVALID_PPT_OUTPUT_OPTIONS";
+    readonly INVALID_PPT_OUTPUT_PATH: "INVALID_PPT_OUTPUT_PATH";
+    readonly INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH";
+    readonly INVALID_PPT_MODE: "INVALID_PPT_MODE";
+    readonly INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT";
 };
 /**
  * Enhanced error class with structured information
@@ -149,6 +161,54 @@ export declare class ErrorFactory {
      * Create an invalid image format error
      */
     static invalidImageFormat(): NeuroLinkError;
+    /**
+     * Create a rate limiter queue full error
+     */
+    static rateLimiterQueueFull(maxQueueSize: number): NeuroLinkError;
+    /**
+     * Create a rate limiter queue timeout error
+     */
+    static rateLimiterQueueTimeout(timeoutMs: number): NeuroLinkError;
+    /**
+     * Create a rate limiter reset error
+     */
+    static rateLimiterReset(): NeuroLinkError;
+    /**
+     * Create a generic missing PPT property error
+     */
+    static missingPPTProperty(field: string, suggestions?: string[]): NeuroLinkError;
+    /**
+     * Create an invalid PPT pages error
+     */
+    static invalidPPTPages(pages: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT format error
+     */
+    static invalidPPTFormat(format: string): NeuroLinkError;
+    /**
+     * Create a generic invalid PPT output options error
+     */
+    static invalidPPTOutputOptions(field: string, value: unknown, validOptions?: string[]): NeuroLinkError;
+    /**
+     * Create an invalid PPT output path error
+     */
+    static invalidPPTOutputPath(path: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT mode error
+     */
+    static invalidPPTMode(): NeuroLinkError;
+    /**
+     * Create an invalid PPT prompt error
+     */
+    static invalidPPTPrompt(reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT logo path error
+     */
+    static invalidPPTLogoPath(path: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT provider error
+     */
+    static invalidPPTProvider(provider: unknown): NeuroLinkError;
 }
 /**
  * Timeout wrapper for async operations

package/dist/lib/utils/errorHandling.js

@@ -40,6 +40,20 @@ export const ERROR_CODES = {
     IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE",
     IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL",
     INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT",
+    // Rate limiter errors
+    RATE_LIMITER_QUEUE_FULL: "RATE_LIMITER_QUEUE_FULL",
+    RATE_LIMITER_QUEUE_TIMEOUT: "RATE_LIMITER_QUEUE_TIMEOUT",
+    RATE_LIMITER_RESET: "RATE_LIMITER_RESET",
+    // PPT validation errors
+    MISSING_PPT_PROPERTIES: "MISSING_PPT_PROPERTIES",
+    INVALID_PPT_PAGES: "INVALID_PPT_PAGES",
+    INVALID_PPT_FORMAT: "INVALID_PPT_FORMAT",
+    INVALID_PPT_PROVIDER: "INVALID_PPT_PROVIDER",
+    INVALID_PPT_OUTPUT_OPTIONS: "INVALID_PPT_OUTPUT_OPTIONS",
+    INVALID_PPT_OUTPUT_PATH: "INVALID_PPT_OUTPUT_PATH",
+    INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH",
+    INVALID_PPT_MODE: "INVALID_PPT_MODE",
+    INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT",
 };
 /**
  * Enhanced error class with structured information
@@ -461,6 +475,229 @@ export class ErrorFactory {
             },
         });
     }
+    // ============================================================================
+    // RATE LIMITER ERRORS
+    // ============================================================================
+    /**
+     * Create a rate limiter queue full error
+     */
+    static rateLimiterQueueFull(maxQueueSize) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.RATE_LIMITER_QUEUE_FULL,
+            message: `Rate limiter queue full: too many pending requests (${maxQueueSize} max)`,
+            category: ErrorCategory.RESOURCE,
+            severity: ErrorSeverity.HIGH,
+            retriable: true,
+            context: { maxQueueSize },
+        });
+    }
+    /**
+     * Create a rate limiter queue timeout error
+     */
+    static rateLimiterQueueTimeout(timeoutMs) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.RATE_LIMITER_QUEUE_TIMEOUT,
+            message: `Rate limiter queue timeout: request exceeded ${timeoutMs}ms wait time`,
+            category: ErrorCategory.TIMEOUT,
+            severity: ErrorSeverity.HIGH,
+            retriable: true,
+            context: { timeoutMs },
+        });
+    }
+    /**
+     * Create a rate limiter reset error
+     */
+    static rateLimiterReset() {
+        return new NeuroLinkError({
+            code: ERROR_CODES.RATE_LIMITER_RESET,
+            message: "Rate limiter was reset while request was pending",
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: true,
+            context: {},
+        });
+    }
+    // ============================================================================
+    // PPT VALIDATION ERRORS
+    // ============================================================================
+    /**
+     * Create a generic missing PPT property error
+     */
+    static missingPPTProperty(field, suggestions) {
+        const defaultSuggestions = [`Provide the required '${field}' field`];
+        return new NeuroLinkError({
+            code: ERROR_CODES.MISSING_PPT_PROPERTIES,
+            message: `PPT generation requires '${field}' field`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field,
+                suggestions: suggestions || defaultSuggestions,
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT pages error
+     */
+    static invalidPPTPages(pages, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PAGES,
+            message: `Invalid pages value '${pages}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.pages",
+                providedValue: pages,
+                suggestions: [
+                    "Use a number between 5 and 50",
+                    "For longer presentations, consider breaking into multiple decks",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT format error
+     */
+    static invalidPPTFormat(format) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_FORMAT,
+            message: `Invalid format '${format}'. Only 'pptx' is supported`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.format",
+                providedValue: format,
+                suggestions: ["Use format: 'pptx' or omit (defaults to 'pptx')"],
+            },
+        });
+    }
+    /**
+     * Create a generic invalid PPT output options error
+     */
+    static invalidPPTOutputOptions(field, value, validOptions) {
+        const suggestions = validOptions
+            ? validOptions.map((opt) => `Use '${opt}'`)
+            : ["Check the documentation for valid options"];
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_OUTPUT_OPTIONS,
+            message: `Invalid ${field} value '${value}'`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: `output.ppt.${field}`,
+                providedValue: value,
+                suggestions,
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT output path error
+     */
+    static invalidPPTOutputPath(path, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_OUTPUT_PATH,
+            message: `Invalid outputPath '${path}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.outputPath",
+                providedValue: path,
+                suggestions: [
+                    "Provide a valid file path string",
+                    "Example: './presentations/my-deck.pptx'",
+                    "Omit to use auto-generated path",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT mode error
+     */
+    static invalidPPTMode() {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_MODE,
+            message: "Presentation generation requires output.mode to be 'ppt'",
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.mode",
+                suggestions: [
+                    "Set output: { mode: 'ppt' } for presentation generation",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT prompt error
+     */
+    static invalidPPTPrompt(reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PROMPT,
+            message: `Invalid PPT prompt: ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "input.text",
+                suggestions: [
+                    "Provide a non-empty text prompt",
+                    "Keep the prompt under 1000 characters",
+                    "Focus on key topics and structure for the presentation",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT logo path error
+     */
+    static invalidPPTLogoPath(path, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_LOGO_PATH,
+            message: `Invalid logoPath '${path}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.logoPath",
+                providedValue: path,
+                suggestions: [
+                    "Provide a valid file path string",
+                    "Example: './assets/logo.png'",
+                    "Omit to skip logo inclusion",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT provider error
+     */
+    static invalidPPTProvider(provider) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PROVIDER,
+            message: `Invalid provider '${provider}' for PPT generation. Supported providers: vertex, openai, azure, anthropic, google-ai, bedrock`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "provider",
+                providedValue: provider,
+                suggestions: [
+                    "Use 'vertex' for Google Vertex AI (Gemini)",
+                    "Use 'openai' for OpenAI GPT models",
+                    "Use 'azure' for Azure OpenAI",
+                    "Use 'anthropic' for Anthropic Claude models",
+                    "Use 'google-ai' for Google AI Studio (Gemini)",
+                    "Use 'bedrock' for AWS Bedrock (Claude, Llama, Nova, etc.)",
+                ],
+            },
+        });
+    }
 }
 /**
  * Timeout wrapper for async operations

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

@@ -137,6 +137,7 @@ export declare const imageUtils: {
      * @param options.maxBytes - Maximum allowed file size (default: 10MB)
      * @param options.maxAttempts - Maximum number of total attempts including initial attempt (default: 3)
      * @returns Promise<string> - Base64 data URI of the downloaded image
+     * Rate-limited to 10 downloads per second to prevent DoS
      */
     urlToBase64DataUri: (url: string, { timeoutMs, maxBytes, maxAttempts, }?: {
         timeoutMs?: number;

package/dist/lib/utils/imageProcessor.js

@@ -3,6 +3,7 @@
  * Handles format conversion for different AI providers
  */
 import { logger } from "./logger.js";
+import { urlDownloadRateLimiter } from "./rateLimiter.js";
 import { withRetry } from "./retryHandler.js";
 import { SYSTEM_LIMITS } from "../core/constants.js";
 /**
@@ -544,8 +545,11 @@ export const imageUtils = {
      * @param options.maxBytes - Maximum allowed file size (default: 10MB)
      * @param options.maxAttempts - Maximum number of total attempts including initial attempt (default: 3)
      * @returns Promise<string> - Base64 data URI of the downloaded image
+     * Rate-limited to 10 downloads per second to prevent DoS
      */
     urlToBase64DataUri: async (url, { timeoutMs = 15000, maxBytes = 10 * 1024 * 1024, maxAttempts = 3, } = {}) => {
+        // Apply rate limiting before download
+        await urlDownloadRateLimiter.acquire();
         // Basic protocol whitelist - fail fast, no retry needed
         if (!/^https?:\/\//i.test(url)) {
             throw new Error("Unsupported protocol");

package/dist/lib/utils/messageBuilder.js

@@ -8,6 +8,7 @@ import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerIma
 import { logger } from "./logger.js";
 import { FileDetector } from "./fileDetector.js";
 import { PDFProcessor, PDFImageConverter } from "./pdfProcessor.js";
+import { urlDownloadRateLimiter } from "./rateLimiter.js";
 import { request, getGlobalDispatcher, interceptors } from "undici";
 import { readFileSync, existsSync } from "fs";
 /**
@@ -623,8 +624,11 @@ function isInternetUrl(input) {
 }
 /**
  * Download image from URL and convert to base64 data URI
+ * Rate-limited to 10 downloads per second to prevent DoS
  */
 async function downloadImageFromUrl(url) {
+    // Apply rate limiting before download
+    await urlDownloadRateLimiter.acquire();
     try {
         const response = await request(url, {
             dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),

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

@@ -4,6 +4,7 @@
  */
 import type { GenerateOptions } from "../types/generateTypes.js";
 import type { VideoOutputOptions } from "../types/multimodal.js";
+import type { PPTOutputOptions } from "../types/pptTypes.js";
 import type { EnhancedValidationResult } from "../types/tools.js";
 import type { StringArray, ValidationSchema } from "../types/typeAliases.js";
 import { NeuroLinkError } from "./errorHandling.js";
@@ -132,6 +133,46 @@ export declare function validateImageForVideo(image: Buffer | string, maxSize?:
  * ```
  */
 export declare function validateVideoGenerationInput(options: GenerateOptions): EnhancedValidationResult;
+export declare const MIN_PPT_PAGES = 5;
+export declare const MAX_PPT_PAGES = 50;
+export declare const MIN_PPT_PROMPT_LENGTH = 10;
+export declare const MAX_PPT_PROMPT_LENGTH = 1000;
+/**
+ * Validate PPT output options (pages, theme, audience, tone, etc.)
+ *
+ * @param options - PPTOutputOptions to validate
+ * @returns NeuroLinkError if invalid, null if valid
+ *
+ * @example
+ * ```typescript
+ * const error = validatePPTOutputOptions({ pages: 100, theme: "invalid" });
+ * // error.code === "INVALID_PPT_PAGES"
+ * ```
+ */
+export declare function validatePPTOutputOptions(options: PPTOutputOptions): NeuroLinkError | null;
+/**
+ * Validate complete PPT generation input
+ *
+ * Validates all requirements for presentation generation:
+ * - output.mode must be "ppt"
+ * - Prompt must be within length limits
+ * - PPT output options must be valid
+ *
+ * @param options - GenerateOptions to validate for PPT generation
+ * @returns EnhancedValidationResult with errors, warnings, and suggestions
+ *
+ * @example
+ * ```typescript
+ * const validation = validatePPTGenerationInput({
+ *   input: { text: "Introducing Our New Product" },
+ *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+ * });
+ * if (!validation.isValid) {
+ *   console.error(validation.errors);
+ * }
+ * ```
+ */
+export declare function validatePPTGenerationInput(options: GenerateOptions): EnhancedValidationResult;
 /**
  * Create a validation error summary for logging
  */