@juspay/neurolink 8.35.2 → 8.37.0

package/dist/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/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/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/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/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/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
  */

package/dist/utils/parameterValidation.js

@@ -603,6 +603,232 @@ export function validateVideoGenerationInput(options) {
     return { isValid: errors.length === 0, errors, warnings, suggestions };
 }
 // ============================================================================
+// PPT VALIDATION (Presentation Generation)
+// ============================================================================
+/**
+ * Valid PPT generation options
+ */
+const VALID_PPT_THEMES = [
+    "modern",
+    "corporate",
+    "creative",
+    "minimal",
+    "dark",
+];
+const VALID_PPT_AUDIENCES = [
+    "business",
+    "students",
+    "technical",
+    "general",
+];
+const VALID_PPT_TONES = [
+    "professional",
+    "casual",
+    "educational",
+    "persuasive",
+];
+const VALID_PPT_ASPECT_RATIOS = ["16:9", "4:3"];
+const VALID_PPT_FORMATS = ["pptx"];
+export const MIN_PPT_PAGES = 5;
+export const MAX_PPT_PAGES = 50;
+export const MIN_PPT_PROMPT_LENGTH = 10;
+export 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 function validatePPTOutputOptions(options) {
+    // Validate pages (slide count) - REQUIRED FIELD
+    if (options.pages === undefined || options.pages === null) {
+        return ErrorFactory.missingPPTProperty("output.ppt.pages", [
+            "Provide the number of slides: output.ppt.pages = 10",
+            "Valid range: 5 to 50 slides",
+            "Recommended: 10 slides for most presentations",
+        ]);
+    }
+    if (typeof options.pages !== "number") {
+        return ErrorFactory.invalidPPTPages(options.pages, "not a number");
+    }
+    if (!Number.isInteger(options.pages)) {
+        return ErrorFactory.invalidPPTPages(options.pages, "not an integer");
+    }
+    if (options.pages < MIN_PPT_PAGES || options.pages > MAX_PPT_PAGES) {
+        return ErrorFactory.invalidPPTPages(options.pages, `out of range (${MIN_PPT_PAGES}-${MAX_PPT_PAGES})`);
+    }
+    // Validate format
+    if (options.format !== undefined &&
+        !VALID_PPT_FORMATS.includes(options.format)) {
+        return ErrorFactory.invalidPPTFormat(options.format);
+    }
+    // Validate theme
+    if (options.theme !== undefined &&
+        !VALID_PPT_THEMES.includes(options.theme)) {
+        return ErrorFactory.invalidPPTOutputOptions("theme", options.theme, Array.from(VALID_PPT_THEMES));
+    }
+    // Validate audience
+    if (options.audience !== undefined &&
+        !VALID_PPT_AUDIENCES.includes(options.audience)) {
+        return ErrorFactory.invalidPPTOutputOptions("audience", options.audience, Array.from(VALID_PPT_AUDIENCES));
+    }
+    // Validate tone
+    if (options.tone !== undefined && !VALID_PPT_TONES.includes(options.tone)) {
+        return ErrorFactory.invalidPPTOutputOptions("tone", options.tone, Array.from(VALID_PPT_TONES));
+    }
+    // Validate aspectRatio
+    if (options.aspectRatio !== undefined &&
+        !VALID_PPT_ASPECT_RATIOS.includes(options.aspectRatio)) {
+        return ErrorFactory.invalidPPTOutputOptions("aspectRatio", options.aspectRatio, Array.from(VALID_PPT_ASPECT_RATIOS));
+    }
+    // Validate includeImages (must be boolean if provided)
+    if (options.includeImages !== undefined &&
+        typeof options.includeImages !== "boolean") {
+        return ErrorFactory.invalidPPTOutputOptions("includeImages", options.includeImages, ["true", "false"]);
+    }
+    // Validate logoPath (string path, Buffer, or ImageWithAltText)
+    if (options.logoPath !== undefined) {
+        if (typeof options.logoPath === "string") {
+            if (options.logoPath.trim().length === 0) {
+                return ErrorFactory.invalidPPTLogoPath(options.logoPath, "empty string");
+            }
+        }
+        else if (Buffer.isBuffer(options.logoPath)) {
+            // ok
+        }
+        else if (typeof options.logoPath === "object" &&
+            "data" in options.logoPath) {
+            const data = options.logoPath.data;
+            if (typeof data === "string") {
+                if (data.trim().length === 0) {
+                    return ErrorFactory.invalidPPTLogoPath(options.logoPath, "empty string");
+                }
+            }
+            else if (!Buffer.isBuffer(data)) {
+                return ErrorFactory.invalidPPTLogoPath(options.logoPath, "invalid data type");
+            }
+        }
+        else {
+            return ErrorFactory.invalidPPTLogoPath(options.logoPath, "invalid type");
+        }
+    }
+    // Validate outputPath (must be non-empty string if provided)
+    if (options.outputPath !== undefined) {
+        if (typeof options.outputPath !== "string") {
+            return ErrorFactory.invalidPPTOutputPath(options.outputPath, "not a string");
+        }
+        if (options.outputPath.trim().length === 0) {
+            return ErrorFactory.invalidPPTOutputPath(options.outputPath, "empty string");
+        }
+    }
+    return null;
+}
+function validatePPTProvider(provider) {
+    // PPT generation supported providers (subset of all AIProviderName values)
+    // Supports major LLM providers with structured output capabilities
+    const validProviders = [
+        "vertex",
+        "openai",
+        "azure",
+        "anthropic",
+        "google-ai",
+        "bedrock",
+    ];
+    // Convert enum or string to lowercase string for comparison
+    const providerString = String(provider).toLowerCase();
+    if (!validProviders.includes(providerString)) {
+        return ErrorFactory.invalidPPTProvider(provider);
+    }
+    return 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 function validatePPTGenerationInput(options) {
+    const errors = [];
+    const warnings = [];
+    const suggestions = [];
+    // Validate prompt/text - trim once for consistency
+    const trimmedPrompt = options.input.text.trim();
+    if (trimmedPrompt === "") {
+        errors.push(toValidationError(ErrorFactory.invalidPPTPrompt("empty prompt")));
+    }
+    else if (trimmedPrompt.length < MIN_PPT_PROMPT_LENGTH) {
+        errors.push(toValidationError(ErrorFactory.invalidPPTPrompt(`prompt too short (${trimmedPrompt.length} characters, min ${MIN_PPT_PROMPT_LENGTH})`)));
+    }
+    else if (trimmedPrompt.length > MAX_PPT_PROMPT_LENGTH) {
+        errors.push(toValidationError(ErrorFactory.invalidPPTPrompt(`prompt too long (${trimmedPrompt.length} characters, max ${MAX_PPT_PROMPT_LENGTH})`)));
+    }
+    // image PPT options if provided
+    if (options.input.images && options.input.images.length > 0) {
+        warnings.push("Images can be unused in PPT generation due to fail in quality standards and can lead to longer generation times.");
+        suggestions.push("Only provide high-quality, relevant images for PPT generation.");
+    }
+    // Validate provider (optional - only validate if explicitly provided)
+    if (options.provider !== undefined) {
+        const providerError = validatePPTProvider(options.provider);
+        if (providerError) {
+            errors.push(toValidationError(providerError));
+        }
+    }
+    // Mode is optional, but if provided must be "ppt"
+    if (options.output?.mode !== undefined && options.output.mode !== "ppt") {
+        errors.push(toValidationError(ErrorFactory.invalidPPTMode()));
+    }
+    // Validate PPT output options
+    if (options.output?.ppt) {
+        const pptError = validatePPTOutputOptions(options.output.ppt);
+        if (pptError) {
+            errors.push(toValidationError(pptError));
+        }
+        // Add specific warnings
+        const pages = options.output.ppt.pages;
+        if (pages > 30) {
+            warnings.push(`Generating ${pages} slides may take significant time (estimated: ${Math.ceil(pages * 3)}-${Math.ceil(pages * 5)} seconds)`);
+        }
+        if (options.output.ppt.includeImages === undefined ||
+            options.output.ppt.includeImages === true) {
+            suggestions.push("Image generation is enabled. Each slide with images will take additional time (~2-5 seconds per image).");
+        }
+    }
+    else {
+        errors.push(toValidationError(ErrorFactory.missingPPTProperty("output.ppt", [
+            "Provide PPT generation options under output.ppt",
+            "Specify number of slides, theme, and other preferences",
+        ])));
+    }
+    // Add helpful suggestions
+    if (errors.length === 0 && warnings.length === 0) {
+        suggestions.push("PPT generation typically takes 30-120 seconds depending on slide count and image generation.");
+    }
+    return { isValid: errors.length === 0, errors, warnings, suggestions };
+}
+// ============================================================================
 // HELPER FUNCTIONS
 // ============================================================================
 /**