Skip to content

ppt-generation.md

Latest commit

 

History

History
961 lines (810 loc) · 31.3 KB

ppt-generation.md

File metadata and controls

961 lines (810 loc) · 31.3 KB
title PPT Generation - AI-Powered Presentations
description Generate professional PowerPoint presentations from text prompts using AI-powered content planning and slide generation
keywords ppt generation, powerpoint, presentation, slides, ai presentation, neurolink, gemini, claude, gpt-4

PPT Generation - AI-Powered Presentations

NeuroLink enables AI-powered PowerPoint presentation generation from text prompts. Transform ideas into professional, visually-appealing presentations with intelligent content planning, multiple slide types, and optional AI-generated images.

Overview

PPT generation in NeuroLink uses a multi-stage pipeline powered by any supported AI provider:

  1. Accepts a text prompt describing the presentation topic via input.text
  2. Plans structured content using AI-powered content planning
  3. Generates individual slides with appropriate types, layouts, and content
  4. Creates optional AI-generated images for visual slides
  5. Assembles a complete .pptx file using pptxgenjs
  6. Returns a PPTGenerationResult containing file path and metadata
graph LR
    A[Text Prompt] --> B[Content Planning AI]
    B --> C[Slide Schemas]
    C --> D[Slide Generator]
    D --> E[Image Generation]
    E --> F[PPTX Assembly]
    F --> G[PPTGenerationResult]
    G --> H[Save to File]
Loading

What You Get

  • Professional presentations – Generate complete PowerPoint files with 5-50 slides
  • 35 slide types – From title and content slides to charts, timelines, dashboards, and composite layouts
  • 5 built-in themes – Modern, Corporate, Creative, Minimal, and Dark
  • AI image generation – Optional background and decorative images using Gemini
  • User-provided images – Use your own images instead of AI generation
  • SDK integration – Use neurolink.generate() with output.mode: "ppt"
  • CLI support – Generate presentations directly from command line
  • Multi-provider support – Works with Vertex AI, OpenAI, Anthropic, Google AI, Azure, and Bedrock

Supported Providers & Models

Provider Compatibility

Provider Recommended Models Slide Types Image Gen Quality Notes
vertex gemini-2.5-pro, gemini-3 All 35 ✅ Native Highest Full feature support
google-ai gemini-2.5-pro, gemini-3 All 35 ✅ Native Highest Full feature support
openai gpt-4o, gpt-4-turbo All 35 ⚠️ External High Uses OpenAI for planning
anthropic claude-4.5-sonnet, claude-3-opus All 35 ⚠️ External Highest Advanced reasoning
azure gpt-4o, gpt-4-turbo All 35 ⚠️ External High Enterprise deployment
bedrock claude-3-sonnet, titan All 35 ⚠️ External High AWS integration

Model Tiers

Tier Models Slide Types Notes
advanced claude-4.5-opus, claude-4.5-sonnet, gpt-4o, gemini-2.5-pro, gemini-3-pro All 35 Full prompt with all features
basic gemini-flash, claude-instant, gpt-3.5 10 core Simplified prompt for speed

Prerequisites

  1. AI provider credentials configured for your chosen provider
  2. For AI images: Vertex AI or Google AI credentials with Gemini access
  3. Sufficient storage: Output files range from 100KB to 10MB+ depending on images

Quick Start

SDK Usage

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

// Basic PPT generation
const result = await neurolink.generate({
  input: {
    text: "Create a presentation about AI in Healthcare",
  },
  provider: "vertex",
  model: "gemini-2.5-pro",
  output: {
    mode: "ppt",
    ppt: {
      pages: 10,
      theme: "modern",
      audience: "business",
      tone: "professional",
    },
  },
});

// Access result
if (result.ppt) {
  console.log(`Presentation saved: ${result.ppt.filePath}`);
  console.log(`Total slides: ${result.ppt.totalSlides}`);
}

With Full Options

import { NeuroLink } from "@juspay/neurolink";
import { readFileSync } from "fs";

const neurolink = new NeuroLink();

const result = await neurolink.generate({
  input: {
    text: "Quarterly Sales Report Q4 2025 - Key achievements, challenges, and outlook",
  },
  provider: "vertex",
  model: "gemini-2.5-pro",
  output: {
    mode: "ppt",
    ppt: {
      pages: 15,
      theme: "corporate",
      audience: "business",
      tone: "professional",
      generateAIImages: true,
      aspectRatio: "16:9",
      outputPath: "./presentations/q4-report.pptx",
      logoPath: readFileSync("./assets/company-logo.png"),
    },
  },
});

console.log("Presentation metadata:", {
  filePath: result.ppt?.filePath,
  slides: result.ppt?.totalSlides,
  theme: result.ppt?.metadata?.theme,
  fileSize: result.ppt?.metadata?.fileSize,
});

With User-Provided Images

import { NeuroLink } from "@juspay/neurolink";
import { readFileSync } from "fs";

const neurolink = new NeuroLink();

// Use your own images instead of AI generation
const result = await neurolink.generate({
  input: {
    text: "Product Launch Presentation for our new smartphone",
    images: [
      readFileSync("./product-hero.jpg"),
      readFileSync("./product-features.png"),
      "./marketing/lifestyle-shot.jpg", // File path also works
    ],
  },
  provider: "anthropic",
  model: "claude-3.5-sonnet",
  output: {
    mode: "ppt",
    ppt: {
      pages: 12,
      theme: "creative",
      generateAIImages: false, // Use provided images only
    },
  },
});

CLI Usage

# Basic PPT generation
npx @juspay/neurolink generate "Introduction to Machine Learning" \
  --outputMode ppt \
  --pptPages 10 \
  --pptOutput ./ml-presentation.pptx

# Full options
npx @juspay/neurolink generate "Company Strategy 2026" \
  --provider vertex \
  --model gemini-2.5-pro \
  --outputMode ppt \
  --pptPages 15 \
  --pptTheme corporate \
  --pptAudience business \
  --pptTone professional \
  --pptAspectRatio 16:9 \
  --pptOutput ./strategy-2026.pptx

# Disable AI image generation
npx @juspay/neurolink generate "Machine Learning 101" \
  --outputMode ppt \
  --pptTheme minimal \
  --pptTone educational \
  --pptNoImages

CLI Arguments

  • --outputMode (string, default: text) — Output mode: text, video, or ppt
  • --pptPages, --pages (number, default: 10) — Number of slides (5-50)
  • --pptTheme (string, default: AI-selected) — Theme: modern, corporate, creative, minimal, dark
  • --pptAudience (string, default: AI-selected) — Target audience: business, students, technical, general
  • --pptTone (string, default: AI-selected) — Presentation tone: professional, casual, educational, persuasive
  • --pptNoImages (boolean, default: false) — Disable AI images for visual slides (images are enabled by default)
  • --pptAspectRatio (string, default: 16:9) — Aspect ratio: 16:9 or 4:3
  • --pptOutput, --po (string, default: auto-generated) — Output file path

Slide Types

NeuroLink supports 35 distinct slide types organized by category:

Opening/Closing Slides

Type Description Layout Options
title Opening slide with main title title-centered, title-bottom
section-header Section divider with large title title-centered
thank-you Final slide with contact info contact-info, title-centered
closing Summary and next steps summary-bullets, title-content

Content Slides

Type Description Layout Options
content Standard title + bullet points title-content, image layouts
agenda Table of contents title-content, two-column
bullets Enhanced bullet points title-content
numbered-list Step-by-step content title-content

Visual Slides

Type Description Image Required
image-focus Large centered image Yes
image-left Image left, content right Yes
image-right Content left, image right Yes
full-bleed-image Full background image Yes
gallery Multiple images grid Yes

Data Slides

Type Description Data Structure
table Data table with headers TableRow[]
chart-bar Bar chart ChartSeries
chart-line Line chart for trends ChartSeries
chart-pie Pie chart for proportions ChartSeries
chart-area Area chart ChartSeries
statistics Big numbers display Statistic[]

Layout Slides

Type Description Columns
two-column Two equal columns 2
three-column Three column layout 3
split-content Asymmetric 60/40 split 2
comparison Side-by-side comparison 2

Special Slides

Type Description Key Content
quote Impactful quote quote, author
timeline Chronological events TimelineItem[]
process-flow Step-by-step process ProcessStep[]
features Feature list with icons FeatureItem[]
team Team member profiles TeamMember[]
icons Icon grid with labels icons[]
conclusion Summary with takeaways bullets

Composite/Dashboard Slides

Type Description Components
dashboard Multi-zone flexible grid charts + stats + bullets
mixed-content Left bullets + right chart bullets + data
stats-grid Multiple stat boxes Statistic[]
icon-grid Icon boxes in grid icons

Themes

Built-in Themes

Theme Colors Best For
modern Blue, Purple, Cyan Tech, Innovation
corporate Dark Blue, Green, Slate Business, Finance
creative Orange, Pink, Yellow Marketing, Design
minimal Black, White, Gray Clean, Professional
dark Cyan, Purple on Dark Tech, Startups

Theme Structure

interface PresentationTheme {
  name: string;
  displayName: string;
  description: string;
  colors: {
    primary: string; // Main accent color
    secondary: string; // Secondary accent
    accent: string; // Highlight color
    background: string; // Slide background
    text: string; // Body text color
    textOnPrimary: string; // Text on primary color
    muted: string; // Muted/caption text
  };
  fonts: {
    heading: string;
    body: string;
    sizes: {
      title: number;
      subtitle: number;
      heading: number;
      body: number;
      caption: number;
    };
  };
}

Type Definitions

PPTOutputOptions

Options for PPT generation configuration:

type PPTOutputOptions = {
  /** Number of slides (5-50) */
  pages: number;
  /** Output format (currently only 'pptx') */
  format?: "pptx";
  /** Presentation theme */
  theme?: "modern" | "corporate" | "creative" | "minimal" | "dark";
  /** Target audience */
  audience?: "business" | "students" | "technical" | "general";
  /** Presentation tone */
  tone?: "professional" | "casual" | "educational" | "persuasive";
  /** Generate AI images for visual slides */
  generateAIImages?: boolean;
  /** Output file path */
  outputPath?: string;
  /** Aspect ratio */
  aspectRatio?: "16:9" | "4:3";
  /** Logo image (Buffer, file path, or ImageWithAltText) */
  logoPath?: Buffer | string | ImageWithAltText;
};

PPTGenerationResult

Result type for generated presentation:

type PPTGenerationResult = {
  /** Path to generated file */
  filePath: string;
  /** Total number of slides */
  totalSlides: number;
  /** Output format */
  format: "pptx";
  /** Provider used for content planning */
  provider: string;
  /** Model used for content planning */
  model: string;
  /** Additional metadata */
  metadata?: {
    theme?: string;
    audience?: string;
    tone?: string;
    imageModel?: string;
    fileSize?: number;
  };
};

Content Structure Types

// Bullet point with optional formatting
type BulletPoint = {
  text: string;
  subBullets?: string[];
  icon?: string;
  emphasis?: boolean;
  fontSize?: number;
  bulletStyle?: "disc" | "number" | "checkmark" | "arrow" | "dash" | "none";
  color?: string;
  bold?: boolean;
};

// Statistics for data slides
type Statistic = {
  value: string;
  label: string;
  trend?: "up" | "down" | "neutral";
  change?: string;
  icon?: string;
};

// Timeline items
type TimelineItem = {
  date: string;
  title: string;
  description?: string;
  icon?: string;
};

// Process steps
type ProcessStep = {
  step: number;
  title: string;
  description?: string;
  icon?: string;
};

// Chart data
type ChartSeries = {
  name: string;
  labels: string[];
  values: number[];
  color?: string;
};

Extended GenerateResult

The generate() function returns an extended result when PPT mode is enabled:

type GenerateResult = {
  content: string;
  provider?: string;
  model?: string;
  usage?: TokenUsage;
  responseTime?: number;

  // PPT-specific field (present when output.mode === "ppt")
  ppt?: PPTGenerationResult;

  // Other optional fields
  toolsUsed?: string[];
  analytics?: AnalyticsData;
  evaluation?: EvaluationData;
};

Configuration & Best Practices

Configuration Options

Option Type Default Required Description
input.text string - Yes Topic/description (10-1000 chars)
input.images Array<Buffer> - No User-provided images
provider string vertex No AI provider for content planning
model string provider default No Model for content planning
output.mode string text Yes Must be "ppt" for PPT output
output.ppt.pages number 10 Yes Number of slides (5-50)
output.ppt.theme string modern No Presentation theme
output.ppt.audience string general No Target audience
output.ppt.tone string professional No Presentation tone
output.ppt.generateAIImages boolean false No Enable AI image generation
output.ppt.aspectRatio string 16:9 No Slide aspect ratio
output.ppt.outputPath string auto-generated No Output file path
output.ppt.logoPath Buffer | string - No Logo for slides

Best Practices

1. Prompt Engineering

// ❌ Vague prompt
const vaguePrompt = "Make a presentation";

// ✅ Specific and detailed
const specificPrompt =
  "Create a presentation about Machine Learning in Healthcare: covering benefits, use cases (diagnosis, drug discovery, patient care), implementation challenges, and future outlook";

// ✅ Include structure hints
const structuredPrompt = `Product Launch Presentation for SmartWatch Pro:
- Start with value proposition
- Cover 5 key features
- Include competitor comparison
- Show pricing tiers
- End with launch timeline and CTA`;

2. Audience & Tone Matching

// Technical audience
const technicalPpt = await neurolink.generate({
  input: {
    text: "Kubernetes Architecture Deep Dive",
  },
  output: {
    mode: "ppt",
    ppt: {
      pages: 15,
      audience: "technical",
      tone: "educational",
      theme: "dark",
    },
  },
});

// Executive audience
const executivePpt = await neurolink.generate({
  input: {
    text: "Digital Transformation ROI Report",
  },
  output: {
    mode: "ppt",
    ppt: {
      pages: 10,
      audience: "business",
      tone: "professional",
      theme: "corporate",
    },
  },
});

3. Image Strategy

// AI-generated images for creative presentations
const creativePpt = await neurolink.generate({
  input: { text: "Future of Space Tourism" },
  output: {
    mode: "ppt",
    ppt: {
      pages: 12,
      theme: "creative",
      generateAIImages: true, // AI generates thematic images
    },
  },
});

// User-provided images for brand consistency
const brandPpt = await neurolink.generate({
  input: {
    text: "Annual Report 2025",
    images: [
      readFileSync("./brand/hero.jpg"),
      readFileSync("./brand/team.jpg"),
      readFileSync("./brand/office.jpg"),
    ],
  },
  output: {
    mode: "ppt",
    ppt: {
      pages: 20,
      generateAIImages: false,
      logoPath: "./brand/logo.png",
    },
  },
});

Comprehensive Examples

Example 1: Basic Presentation

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

async function generateBasicPresentation() {
  const result = await neurolink.generate({
    input: {
      text: "Introduction to Cloud Computing: Benefits, Types, and Best Practices",
    },
    provider: "vertex",
    model: "gemini-2.5-pro",
    output: {
      mode: "ppt",
      ppt: {
        pages: 10,
        theme: "modern",
        audience: "general",
        tone: "educational",
      },
    },
  });

  if (result.ppt) {
    console.log({
      filePath: result.ppt.filePath,
      totalSlides: result.ppt.totalSlides,
      provider: result.ppt.provider,
    });
  }
}

Example 2: Business Presentation with Analytics

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

async function generateBusinessPresentation() {
  const result = await neurolink.generate({
    input: {
      text: `Q4 2025 Sales Performance Report:
        - Revenue: $12.5M (up 23% YoY)
        - New customers: 450
        - Customer retention: 94%
        - Top products: Enterprise Suite, Cloud Platform
        - Challenges: Supply chain, competition
        - 2026 targets: $18M revenue, 600 new customers`,
    },
    provider: "anthropic",
    model: "claude-3.5-sonnet",
    enableAnalytics: true,
    output: {
      mode: "ppt",
      ppt: {
        pages: 15,
        theme: "corporate",
        audience: "business",
        tone: "professional",
        outputPath: "./reports/q4-sales.pptx",
      },
    },
  });

  console.log("Analytics:", result.analytics);
  console.log("Presentation:", result.ppt);
}

Example 3: Technical Documentation with Code

import { NeuroLink } from "@juspay/neurolink";

const neurolink = new NeuroLink();

async function generateTechnicalDocs() {
  const result = await neurolink.generate({
    input: {
      text: `API Integration Guide for Payment Gateway:
        - Authentication (OAuth 2.0, API Keys)
        - Endpoints overview
        - Request/Response formats
        - Error handling
        - Code examples in TypeScript
        - Testing and sandbox environment
        - Security best practices`,
    },
    provider: "openai",
    model: "gpt-4o",
    output: {
      mode: "ppt",
      ppt: {
        pages: 12,
        theme: "dark",
        audience: "technical",
        tone: "educational",
      },
    },
  });

  return result.ppt;
}

Example 4: Batch Presentation Generation

import { NeuroLink } from "@juspay/neurolink";
import pLimit from "p-limit";

const neurolink = new NeuroLink();
const limit = pLimit(2); // Max 2 concurrent generations

const topics = [
  { topic: "AI in Healthcare", audience: "business" },
  { topic: "Machine Learning Basics", audience: "students" },
  { topic: "Cloud Architecture Patterns", audience: "technical" },
];

async function batchGenerate() {
  const results = await Promise.all(
    topics.map((item) =>
      limit(async () => {
        const result = await neurolink.generate({
          input: { text: item.topic },
          output: {
            mode: "ppt",
            ppt: {
              pages: 10,
              audience: item.audience as any,
              outputPath: `./presentations/${item.topic.replace(/\s+/g, "-").toLowerCase()}.pptx`,
            },
          },
        });
        return {
          topic: item.topic,
          filePath: result.ppt?.filePath,
          slides: result.ppt?.totalSlides,
        };
      }),
    ),
  );

  console.table(results);
}

Example 5: Error Handling

import { NeuroLink, NeuroLinkError, PPTError } from "@juspay/neurolink";

const neurolink = new NeuroLink();

async function generateWithErrorHandling(topic: string) {
  try {
    const result = await neurolink.generate({
      input: { text: topic },
      output: {
        mode: "ppt",
        ppt: {
          pages: 10,
          theme: "modern",
        },
      },
      timeout: 300000, // 5 minutes for PPT generation
    });

    return result.ppt;
  } catch (error) {
    if (error instanceof PPTError) {
      console.error(`PPT Error [${error.code}]:`, error.message);

      switch (error.code) {
        case "PPT_PLANNING_FAILED":
          console.error("Content planning failed - try a different prompt");
          break;
        case "PPT_INVALID_AI_RESPONSE":
          console.error(
            "AI returned invalid response - retry with different model",
          );
          break;
        case "PPT_IMAGE_GENERATION_FAILED":
          console.error("Image generation failed - try without AI images");
          break;
        case "PPT_ASSEMBLY_FAILED":
          console.error("PPTX assembly failed - check file permissions");
          break;
        case "PPT_FILE_WRITE_FAILED":
          console.error("File write failed - check disk space and permissions");
          break;
        case "PPT_TIMEOUT":
          console.error("Generation timed out - try fewer slides");
          break;
      }
    } else if (error instanceof NeuroLinkError) {
      console.error(`NeuroLink Error:`, error.message);
    }

    throw error;
  }
}

Error Handling & Validation

Validation Rules

Parameter Validation Error Type Example Message
input.text 10-1000 characters PPTError Prompt must be 10-1000 characters
output.ppt.pages 5-50 slides PPTError Pages must be between 5 and 50
output.ppt.theme Valid theme name PPTError Invalid theme. Use: modern, corporate...
output.ppt.audience Valid audience type PPTError Invalid audience type
output.ppt.tone Valid tone type PPTError Invalid tone type
output.ppt.aspectRatio 16:9 or 4:3 PPTError Invalid aspect ratio

Error Codes

const PPT_ERROR_CODES = {
  PLANNING_FAILED: "PPT_PLANNING_FAILED",
  INVALID_AI_RESPONSE: "PPT_INVALID_AI_RESPONSE",
  IMAGE_GENERATION_FAILED: "PPT_IMAGE_GENERATION_FAILED",
  ASSEMBLY_FAILED: "PPT_ASSEMBLY_FAILED",
  FILE_WRITE_FAILED: "PPT_FILE_WRITE_FAILED",
  INVALID_INPUT: "PPT_INVALID_INPUT",
  TIMEOUT: "PPT_TIMEOUT",
};

Troubleshooting

Symptom Cause Solution
Content planning fails Invalid/vague prompt Use more specific, detailed prompts
Slides have wrong types Model not following instructions Try advanced-tier model (claude-3.5, gpt-4o)
Images not generating generateAIImages not enabled Set generateAIImages: true
Images fail to generate Missing Vertex AI credentials Configure GOOGLE_APPLICATION_CREDENTIALS
File write fails Permission denied Check output directory permissions
Generation times out Too many slides with images Reduce pages or disable AI images
Bullet formatting wrong AI not following format Use simplified slide types
Charts have no data AI didn't generate chart data Provide explicit data in prompt
Logo not appearing Invalid logo path/buffer Verify logo file exists and is valid image
Incorrect aspect ratio Using wrong dimension Ensure aspectRatio matches content design

Debug Mode

// Enable verbose logging
const neurolink = new NeuroLink({
  debug: true,
  logLevel: "verbose",
});

// Or via environment variable
// export NEUROLINK_DEBUG=true

Testing

Unit Test Example

import { describe, it, expect, vi } from "vitest";
import { NeuroLink } from "@juspay/neurolink";

describe("PPT Generation", () => {
  it("should generate presentation with valid options", async () => {
    const neurolink = new NeuroLink();

    const result = await neurolink.generate({
      input: { text: "Test presentation about AI" },
      output: {
        mode: "ppt",
        ppt: {
          pages: 5,
          theme: "modern",
          audience: "general",
          tone: "professional",
        },
      },
    });

    expect(result.ppt).toBeDefined();
    expect(result.ppt?.filePath).toMatch(/\.pptx$/);
    expect(result.ppt?.totalSlides).toBeGreaterThanOrEqual(5);
    expect(result.ppt?.format).toBe("pptx");
  });

  it("should throw error for invalid page count", async () => {
    const neurolink = new NeuroLink();

    await expect(
      neurolink.generate({
        input: { text: "Test" },
        output: {
          mode: "ppt",
          ppt: { pages: 100 }, // Invalid: max is 50
        },
      }),
    ).rejects.toThrow();
  });
});

Mock Strategy for CI/CD

import { vi } from "vitest";

vi.mock("@juspay/neurolink", () => ({
  NeuroLink: vi.fn().mockImplementation(() => ({
    generate: vi.fn().mockResolvedValue({
      content: "",
      provider: "vertex",
      model: "gemini-2.5-pro",
      ppt: {
        filePath: "./test-output.pptx",
        totalSlides: 10,
        format: "pptx",
        provider: "vertex",
        model: "gemini-2.5-pro",
        metadata: {
          theme: "modern",
          audience: "general",
          tone: "professional",
        },
      },
    }),
  })),
}));

Limitations

Limitation Description Workaround
Max slides 50 slides per presentation Split into multiple presentations
Min slides 5 slides minimum Use at least 5 pages
Output format Only PPTX supported Convert with external tools if needed
Image generation Only with Vertex AI / Google AI Use user-provided images
Custom templates Not supported yet Use theme customization
Animations Basic transitions only Edit in PowerPoint after generation
Video embedding Not supported Add videos manually after generation

Performance Optimization

Generation Time Estimates

Configuration Estimated Time Notes
10 slides, no images 15-30s Fast, text-only
10 slides, with AI images 60-120s Image generation adds time
20 slides, no images 30-60s Linear scaling
20 slides, with AI images 120-240s Parallel image generation
50 slides, no images 60-120s Large presentation
50 slides, with AI images 300-600s Consider splitting

Optimization Tips

  1. Disable AI images for faster generation: generateAIImages: false
  2. Use basic-tier models for simple presentations: gemini-2.5-flash
  3. Provide user images instead of AI generation for brand consistency
  4. Limit slide count to what's actually needed
  5. Use structured prompts for better AI content planning

Related Features

Implementation Files

File Purpose
src/lib/features/ppt/presentationOrchestrator.ts Main orchestration pipeline
src/lib/features/ppt/contentPlanner.ts AI-powered content planning
src/lib/features/ppt/slideGenerator.ts Individual slide generation
src/lib/features/ppt/slideRenderers.ts Slide type rendering functions
src/lib/features/ppt/constants.ts Themes, prompts, and configuration
src/lib/features/ppt/types.ts Type definitions
src/lib/types/pptTypes.ts Public API types
src/lib/utils/parameterValidation.ts Input validation: validatePPTGenerationInput()

Next: Video Generation | Multimodal Chat