ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/models/generation.py

@@ -0,0 +1,85 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class VideoGenerationPrompt(BaseModel):
+    """Input schema for generating video content with VEO models."""
+
+    prompt: str = Field(
+        ...,
+        description="The text prompt describing the desired video content."
+    )
+
+    model: str = Field(
+        ...,
+        description="The video generation model to use (e.g., 'veo-3.0-generate-001')."
+    )
+
+    aspect_ratio: str = Field(
+        default="16:9",
+        description="The desired aspect ratio (e.g., '16:9', '9:16', '1:1')."
+    )
+
+    resolution: Optional[str] = Field(
+        default="720p",
+        description="Video resolution ('720p' or '1080p'). Default is '720p'."
+    )
+
+    negative_prompt: Optional[str] = Field(
+        default='',
+        description="A description of what to avoid in the video (e.g., 'cartoon, low quality')."
+    )
+
+    number_of_videos: int = Field(
+        default=1,
+        description="The number of videos to generate per request (typically 1)."
+    )
+
+    duration: Optional[int] = Field(
+        None,
+        description="Optional duration in seconds for the video (if supported by model)."
+    )
+
+    # Additional metadata fields (optional)
+    seed: Optional[int] = Field(
+        None,
+        description="Optional seed for reproducible generation (if supported)."
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "prompt": "A cinematic shot of a majestic lion in the savannah",
+                "model": "veo-3.0-generate-001",
+                "aspect_ratio": "16:9",
+                "resolution": "1080p",
+                "negative_prompt": "cartoon, drawing, low quality",
+                "number_of_videos": 1
+            }
+        }
+
+def validate_aspect_ratio(aspect_ratio: str) -> bool:
+    """Validate that aspect ratio is in correct format."""
+    valid_ratios = ["16:9", "9:16", "1:1", "4:3", "3:4", "21:9"]
+    return aspect_ratio in valid_ratios
+
+
+def validate_resolution(resolution: str) -> bool:
+    """Validate that resolution is supported."""
+    valid_resolutions = ["720p", "1080p"]
+    return resolution in valid_resolutions
+
+
+# # Example usage:
+# if __name__ == "__main__":
+#     # Create a video generation prompt
+#     prompt = VideoGenerationPrompt(
+#         prompt="A time-lapse of a sunset over the ocean",
+#         model="veo-3.0-generate-001",
+#         aspect_ratio="16:9",
+#         resolution="1080p",
+#         negative_prompt="people, buildings, text",
+#         number_of_videos=1
+#     )
+
+#     print(prompt.model_dump_json(indent=2))

parrot/models/google.py

@@ -0,0 +1,223 @@
+"""
+Google Related Models to be used in GenAI.
+"""
+from typing import Literal, List, Dict, Optional
+from enum import Enum
+from pydantic import BaseModel, Field
+
+class GoogleModel(Enum):
+    """Enum for Google AI models."""
+    GEMINI_3_PRO_PREVIEW = "gemini-3-pro-preview"
+    GEMINI_2_5_FLASH = "gemini-2.5-flash"
+    GEMINI_2_5_FLASH_PREVIEW = "gemini-2.5-flash-preview-09-2025"
+    GEMINI_2_5_FLASH_LITE_PREVIEW = "gemini-2.5-flash-lite-preview-09-2025"
+    GEMINI_2_5_PRO = "gemini-2.5-pro"
+    GEMINI_2_0_FLASH = "gemini-2.0-flash-001"
+    GEMINI_PRO_LATEST = "gemini-pro-latest"
+    GEMINI_FLASH_LATEST = "gemini-flash-latest"
+    GEMINI_FLASH_LITE_LATEST = "gemini-flash-lite-latest"
+    IMAGEN_3 = "imagen-3.0-generate-002"
+    IMAGEN_4 = "imagen-4.0-generate-preview-06-06"
+    GEMINI_2_0_IMAGE_GENERATION = "gemini-2.0-flash-preview-image-generation"
+    GEMINI_2_5_FLASH_TTS = "gemini-2.5-flash-preview-tts"
+    GEMINI_2_5_PRO_TTS = "gemini-2.5-pro-preview-tts"
+    GEMINI_2_5_FLASH_IMAGE_PREVIEW = "gemini-2.5-flash-image-preview"
+    VEO_3_0 = "veo-3.0-generate-preview"
+    VEO_2_0 = "veo-2.0-generate-001"
+    VEO_3_0_FAST = "veo-3.0-fast-generate-001"
+
+# NEW: Enum for all valid TTS voice names
+class TTSVoice(str, Enum):
+    """Google TTS voices."""
+    ACHERNAR = "achernar"
+    ACHIRD = "achird"
+    ALGENIB = "algenib"
+    ALGIEBA = "algieba"
+    ALNILAM = "alnilam"
+    AOEDE = "aoede"
+    AUTONOE = "autonoe"
+    CALLIRRHOE = "callirrhoe"
+    CHARON = "charon"
+    DESPINA = "despina"
+    ENCELADUS = "enceladus"
+    ERINOME = "erinome"
+    FENRIR = "fenrir"
+    GACRUX = "gacrux"
+    IAPETUS = "iapetus"
+    KORE = "kore"
+    LAOMEDEIA = "laomedeia"
+    LEDA = "leda"
+    ORUS = "orus"
+    PUCK = "puck"
+    PULCHERRIMA = "pulcherrima"
+    RASALGETHI = "rasalgethi"
+    SADACHBIA = "sadachbia"
+    SADALTAGER = "sadaltager"
+    SCHEDAR = "schedar"
+    SULAFAT = "sulafat"
+    UMBRIEL = "umbriel"
+    VINDEMIATRIX = "vindemiatrix"
+    ZEPHYR = "zephyr"
+    ZUBENELGENUBI = "zubenelgenubi"
+
+
+class VertexAIModel(Enum):
+    """Enum for Vertex AI models."""
+    GEMINI_2_5_FLASH = "gemini-2.5-flash"
+    GEMINI_2_5_FLASH_LITE_PREVIEW = "gemini-2.5-flash-lite-preview-06-17"
+    GEMINI_2_5_PRO = "gemini-2.5-pro"
+    GEMINI_2_0_FLASH = "gemini-2.0-flash-001"
+    IMAGEN_3_FAST = "Imagen 3 Fast"
+
+
+class FictionalSpeaker(BaseModel):
+    """Configuration for a fictional character in the generated script."""
+    name: str = Field(
+        ...,
+        description="The name of the fictional speaker (e.g., 'Alex', 'Dr. Evans')."
+    )
+    characteristic: str = Field(
+        ...,
+        description="A descriptive personality trait for the voice model, e.g., 'charismatic and engaging', 'skeptical and cautious', 'bored'."
+    )
+    role: Literal['interviewer', 'interviewee'] = Field(
+        ...,
+        description="The role of the speaker in the conversation."
+    )
+    gender: Literal['female', 'male', 'neutral'] = Field(
+        default='neutral',
+        description="The gender of the speaker.",
+    )
+
+
+class ConversationalScriptConfig(BaseModel):
+    """
+    Configuration for generating a conversational script with fictional characters.
+    """
+    report_text: str = Field(
+        ...,
+        description="The main text content of the script."
+    )
+    speakers: List[FictionalSpeaker] = Field(
+        ...,
+        description="A list of fictional speakers to include in the script."
+    )
+    context: str = Field(
+        ...,
+        description="Background context for the conversation, e.g., 'Discussing recent scientific discoveries'."
+    )
+    length: int = Field(
+        1000,
+        description="Desired length of the script in words."
+    )
+    system_prompt: Optional[str] = Field(
+        None,
+        description="An optional system prompt to guide the AI's behavior during script generation."
+    )
+    system_instruction: Optional[str] = Field(
+        None,
+        description="An optional system instruction to provide additional context or constraints for the script generation."
+    )
+
+
+# Define the gender type for clarity and validation
+Gender = Literal["female", "male", "neutral"]
+
+
+class VoiceProfile(BaseModel):
+    """
+    Represents a single pre-built generative voice, mapping its name
+    to its known characteristics and gender.
+    """
+    voice_name: str = Field(..., description="The official name of the voice (e.g., 'Erinome').")
+    characteristic: str = Field(..., description="The primary characteristic of the voice (e.g., 'Clear', 'Upbeat').")
+    gender: Gender = Field(..., description="The perceived gender of the voice.")
+
+
+# This list is based on the official documentation for Google's generative voices.
+# It represents the "HTML table" data you referred to.
+ALL_VOICE_PROFILES: List[VoiceProfile] = [
+    VoiceProfile(voice_name="Zephyr", characteristic="Bright", gender="female"),
+    VoiceProfile(voice_name="Puck", characteristic="Upbeat", gender="male"),
+    VoiceProfile(voice_name="Charon", characteristic="Informative", gender="male"),
+    VoiceProfile(voice_name="Kore", characteristic="Firm", gender="female"),
+    VoiceProfile(voice_name="Fenrir", characteristic="Excitable", gender="male"),
+    VoiceProfile(voice_name="Leda", characteristic="Youthful", gender="female"),
+    VoiceProfile(voice_name="Orus", characteristic="Firm", gender="male"),
+    VoiceProfile(voice_name="Aoede", characteristic="Breezy", gender="female"),
+    VoiceProfile(voice_name="Callirrhoe", characteristic="Easy-going", gender="female"),
+    VoiceProfile(voice_name="Autonoe", characteristic="Bright", gender="female"),
+    VoiceProfile(voice_name="Enceladus", characteristic="Breathy", gender="male"),
+    VoiceProfile(voice_name="Iapetus", characteristic="Clear", gender="male"),
+    VoiceProfile(voice_name="Umbriel", characteristic="Easy-going", gender="male"),
+    VoiceProfile(voice_name="Algieba", characteristic="Smooth", gender="male"),
+    VoiceProfile(voice_name="Despina", characteristic="Smooth", gender="female"),
+    VoiceProfile(voice_name="Erinome", characteristic="Clear", gender="female"),
+    VoiceProfile(voice_name="Algenib", characteristic="Gravelly", gender="male"),
+    VoiceProfile(voice_name="Rasalgethi", characteristic="Informative", gender="male"),
+    VoiceProfile(voice_name="Laomedeia", characteristic="Upbeat", gender="female"),
+    VoiceProfile(voice_name="Achernar", characteristic="Soft", gender="female"),
+    VoiceProfile(voice_name="Alnilam", characteristic="Firm", gender="female"),
+    VoiceProfile(voice_name="Schedar", characteristic="Even", gender="female"),
+    VoiceProfile(voice_name="Gacrux", characteristic="Mature", gender="female"),
+    VoiceProfile(voice_name="Pulcherrima", characteristic="Forward", gender="female"),
+    VoiceProfile(voice_name="Achird", characteristic="Friendly", gender="female"),
+    VoiceProfile(voice_name="Zubenelgenubi", characteristic="Casual", gender="male"),
+    VoiceProfile(voice_name="Vindemiatrix", characteristic="Gentle", gender="female"),
+    VoiceProfile(voice_name="Sadachbia", characteristic="Lively", gender="female"),
+    VoiceProfile(voice_name="Sadaltager", characteristic="Knowledgeable", gender="male"),
+    VoiceProfile(voice_name="Sulafat", characteristic="Warm", gender="female"),
+]
+
+class VoiceRegistry:
+    """
+    A comprehensive registry for managing and querying available voice profiles.
+    """
+    def __init__(self, profiles: List[VoiceProfile]):
+        """Initializes the registry with a list of voice profiles."""
+        self._voices: Dict[str, VoiceProfile] = {
+            profile.voice_name.lower(): profile for profile in profiles
+        }
+
+    def find_voice_by_name(self, name: str) -> Optional[VoiceProfile]:
+        """
+        Finds a voice profile by its name (case-insensitive).
+
+        Args:
+            name: The name of the voice to find (e.g., 'Erinome', 'puck').
+        Returns:
+            A VoiceProfile object if found, otherwise None.
+        """
+        return self._voices.get(name.lower())
+
+    def get_all_voices(self) -> List[VoiceProfile]:
+        """Returns a list of all voice profiles in the registry."""
+        return list(self._voices.values())
+
+    def get_voices_by_gender(self, gender: Gender) -> List[VoiceProfile]:
+        """
+        Filters and returns all voices matching the specified gender.
+
+        Args:
+            gender: The gender to filter by ('female', 'male', or 'neutral').
+        Returns:
+            A list of matching VoiceProfile objects.
+        """
+        return [
+            profile for profile in self._voices.values() if profile.gender == gender
+        ]
+
+    def get_voices_by_characteristic(self, characteristic: str) -> List[VoiceProfile]:
+        """
+        Filters and returns all voices with a specific characteristic (case-insensitive).
+
+        Args:
+            characteristic: The characteristic to search for (e.g., 'Clear', 'upbeat').
+        Returns:
+            A list of matching VoiceProfile objects.
+        """
+        search_char = characteristic.lower()
+        return [
+            profile for profile in self._voices.values()
+            if profile.characteristic.lower() == search_char
+        ]

parrot/models/groq.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+class GroqModel(Enum):
+    """Description for Enabled Groq models.
+
+    Only these models are supporting Structured Output:
+    - meta-llama/llama-4-maverick-17b-128e-instruct
+    - meta-llama/llama-4-scout-17b-16e-instruct
+
+    Also, streaming output is not supported with structured outputs.
+    """
+    KIMI_K2_INSTRUCT = "moonshotai/kimi-k2-instruct-0905"
+    LLAMA_4_SCOUT_17B = "meta-llama/llama-4-scout-17b-16e-instruct"
+    LLAMA_4_MAVERICK_17B = "meta-llama/llama-4-maverick-17b-128e-instruct"
+    MISTRAL_SABA_24B = "mistral-saba-24b"
+    DEEPSEEK_R1_DISTILL_70B = "deepseek-r1-distill-llama-70b"
+    LLAMA_3_3_70B_VERSATILE = "llama-3.3-70b-versatile"
+    LLAMA_3_1_8B_INSTANT = "llama-3.1-8b-instant"
+    GEMMA2_9B_IT = "gemma2-9b-it"
+    QWEN_QWEN3_32B = "qwen/qwen3-32b"
+    OPENAI_GPT_OSS_20B = "openai/gpt-oss-20b"
+    OPENAI_GPT_OSS_120B = "openai/gpt-oss-120b"
+    OPENAI_GPT_OSS_SAFEGUARD_20B = "openai/gpt-oss-safeguard-20b"

parrot/models/openai.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class OpenAIModel(Enum):
+    """Enum class for OpenAI models."""
+    GPT5_MINI = "gpt-5-mini"
+    GPT5 = "gpt-5"
+    GPT5_CHAT = "gpt-5-chat-latest"
+    GPT5_PRO = "gpt-5-pro"
+    GPT5_NANO = "gpt-5-nano"
+    GPT4_TURBO = "gpt-4-turbo"
+    GPT3_5_TURBO = "gpt-3.5-turbo"
+    GPT4_1 = "gpt-4.1"
+    GPT_4_1_MINI = "gpt-4.1-mini"
+    GPT_4_1_NANO = "gpt-4.1-nano"
+    GPT_O4 = "gpt-4o-2024-08-06"
+    GPT4 = "gpt-4"
+    GPT_4O_MINI = "gpt-4o-mini"
+    GPT_4O_SEARCH = "gpt-4o-search-preview"
+    GPT_4O_MINI_SEARCH = "gpt-4o-mini-search-preview"
+    O4_MINI = "o4-mini"
+    O4_MINI_DEEP_RESEARCH = "o4-mini-deep-research"
+    O3 = "o3"
+    O3_MINI = "o3-mini"
+    O3_PRO = "o3-pro"
+    O3_DEEP_RESEARCH = "o3-deep-research"
+    GPT_4O = "gpt-4o"
+    GPT_IMAGE_1 = "gpt-image-1"
+    SORA = "sora"
+    SORA_2 = "sora-2"

parrot/models/outputs.py

@@ -0,0 +1,285 @@
+from datetime import datetime
+from typing import (
+    List,
+    Optional,
+    Any,
+    Union,
+    Callable,
+    Literal,
+    get_type_hints,
+    get_origin,
+    get_args
+)
+from enum import Enum
+from dataclasses import dataclass, fields, is_dataclass, MISSING
+import json
+from pydantic import BaseModel, Field
+from .basic import OutputFormat
+
+
+class OutputType(str, Enum):
+    """Types of outputs that can be rendered"""
+    TEXT = "text"
+    MARKDOWN = "markdown"
+    DATAFRAME = "dataframe"
+    FOLIUM_MAP = "folium_map"
+    PLOTLY_CHART = "plotly_chart"
+    MATPLOTLIB_FIGURE = "matplotlib_figure"
+    BOKEH_PLOT = "bokeh_plot"
+    ALTAIR_CHART = "altair_chart"
+    PANEL_DASHBOARD = "panel_dashboard"
+    HTML_WIDGET = "html_widget"
+    IMAGE = "image"
+    JSON_DATA = "json_data"
+    MIXED = "mixed"  # Multiple output types
+
+
+class OutputMode(str, Enum):
+    """Output mode enumeration"""
+    DEFAULT = "default"          # Keep as-is (BaseModel/dataclass)
+    JSON = "json"               # Serialize to JSON (using orjson)
+    TERMINAL = "terminal"       # Render for terminal display (using Rich)
+    MARKDOWN = "markdown"       # Convert to markdown
+    YAML = "yaml"               # Serialize to YAML (using yaml-rs)
+    HTML = "html"               # Convert to HTML elements (using Panel)
+    JINJA2 = "jinja2"           # Pass to Jinja2 template (using jinja2 templates)
+    JUPYTER = "jupyter"         # Render for Jupyter notebook
+    NOTEBOOK = "notebook"       # Render for Jupyter notebook
+    TEMPLATE_REPORT = "template_report"  # Pass to Jinja2 template (using jinja2 templates)
+    APPLICATION = "application"  # Wrap in app (Streamlit/React/Svelte/HTML+TS)
+    CHART = "chart"               # Generate chart visualization
+    ALTAIR = "altair"           # Generate Altair chart visualization
+    PLOTLY = "plotly"
+    MATPLOTLIB = "matplotlib"
+    BOKEH = "bokeh"
+    SEABORN = "seaborn"
+    CODE = "code"
+    MAP = "map"                   # Generate map visualization
+    IMAGE = "image"             # render the image as a base64 embed into HTML <img>
+    D3 = "d3"                   # Generate D3.js visualization
+    ECHARTS = "echarts"         # Generate ECharts visualization
+    TABLE = "table"             # Generate table visualization
+    HOLOVIEWS = "holoviews"   # Generate HoloViews visualization
+    CARD = "card"
+
+@dataclass
+class StructuredOutputConfig:
+    """Configuration for structured output parsing."""
+    output_type: type
+    format: OutputFormat = OutputFormat.JSON
+    custom_parser: Optional[Callable[[str], Any]] = None
+
+    def get_schema(self) -> dict[str, Any]:
+        """
+        Extract JSON schema from output_type.
+        Supports both Pydantic models and dataclasses.
+        """
+        # Check if it's a Pydantic model
+        if hasattr(self.output_type, 'model_json_schema'):
+            # Pydantic v2
+            return self.output_type.model_json_schema()
+        elif hasattr(self.output_type, 'schema'):
+            # Pydantic v1
+            return self.output_type.schema()
+
+        # Check if it's a dataclass
+        elif is_dataclass(self.output_type):
+            return self._dataclass_to_schema(self.output_type)
+
+        else:
+            raise ValueError(
+                f"output_type must be a Pydantic model or dataclass, "
+                f"got {type(self.output_type)}"
+            )
+
+    def _dataclass_to_schema(self, dc: type) -> dict[str, Any]:
+        """Convert a dataclass to JSON schema."""
+        type_hints = get_type_hints(dc)
+        properties = {}
+        required = []
+
+        for field in fields(dc):
+            field_type = type_hints.get(field.name, Any)
+            field_schema = self._python_type_to_json_schema(field_type)
+
+            # Add description from field metadata if available
+            if field.metadata:
+                field_schema["description"] = field.metadata.get("description", "")
+
+            properties[field.name] = field_schema
+
+            # Check if field is required (no default value)
+            if field.default == field.default_factory == MISSING:
+                required.append(field.name)
+
+        schema = {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+            "title": dc.__name__
+        }
+
+        # Add docstring as description if available
+        if dc.__doc__:
+            schema["description"] = dc.__doc__.strip()
+
+        return schema
+
+    def _python_type_to_json_schema(self, py_type: Any) -> dict[str, Any]:
+        """Convert Python type hints to JSON schema types."""
+        origin = get_origin(py_type)
+
+        # Handle Optional types
+        if origin is Union:
+            args = get_args(py_type)
+            if type(None) in args:
+                # It's Optional[T]
+                non_none_types = [t for t in args if t is not type(None)]
+                if len(non_none_types) == 1:
+                    return self._python_type_to_json_schema(non_none_types[0])
+
+        # Handle List types
+        if origin is list:
+            item_type = get_args(py_type)[0] if get_args(py_type) else Any
+            return {
+                "type": "array",
+                "items": self._python_type_to_json_schema(item_type)
+            }
+
+        # Handle Dict types
+        if origin is dict:
+            return {"type": "object"}
+
+        # Basic type mappings
+        type_map = {
+            str: {"type": "string"},
+            int: {"type": "integer"},
+            float: {"type": "number"},
+            bool: {"type": "boolean"},
+            list: {"type": "array"},
+            dict: {"type": "object"},
+        }
+
+        return type_map.get(py_type, {"type": "string"})
+
+    def format_schema_instruction(self) -> str:
+        """
+        Format the schema as an instruction for the system prompt.
+        """
+        schema = self.get_schema()
+        return f"""Respond with a valid JSON object that strictly matches the requested schema.
+
+Schema:
+```json
+{json.dumps(schema, indent=2)}
+```
+
+Rules:
+- Output ONLY valid JSON matching this schema
+- Do not include any explanatory text before or after the JSON
+- All required fields must be present
+- Field types must match exactly"""
+
+
+class BoundingBox(BaseModel):
+    """Represents a detected object with its location and details."""
+    object_id: str = Field(..., description="Unique identifier for this detection")
+    brand: str = Field(..., description="Product brand (Epson, HP, Canon, etc.)")
+    model: Optional[str] = Field(None, description="Product model if identifiable")
+    product_type: str = Field(
+        ..., description="Type of product (printer, scanner, ink cartridge, etc.)"
+    )
+    description: str = Field(..., description="Brief description of the product")
+    confidence: float = Field(..., description="Confidence level (0.0 to 1.0)")
+    # Simple bounding box as [x1, y1, x2, y2] normalized coordinates (0.0 to 1.0)
+    bbox: List[float] = Field(
+        ..., description="Bounding box coordinates [x1, y1, x2, y2] as normalized values (0.0-1.0)"
+    )
+
+
+class ObjectDetectionResult(BaseModel):
+    """A list of all prominent items detected in the image."""
+    analysis: str = Field(
+        ...,
+        description="A detailed text analysis of the image that answers the user's prompt."
+    )
+    total_count: int = Field(..., description="Total number of products detected")
+    detections: List[BoundingBox] = Field(
+        default_factory=list,
+        description="A list of bounding boxes for all prominent detected objects."
+    )
+
+class ImageGenerationPrompt(BaseModel):
+    """Input schema for generating an image."""
+    prompt: str = Field(..., description="The main text prompt describing the desired image.")
+    styles: Optional[List[str]] = Field(default_factory=list, description="Optional list of styles to apply (e.g., 'photorealistic', 'cinematic', 'anime').")
+    model: str = Field(description="The image generation model to use.")
+    negative_prompt: Optional[str] = Field(None, description="A description of what to avoid in the image.")
+    aspect_ratio: str = Field(default="1:1", description="The desired aspect ratio (e.g., '1:1', '16:9', '9:16').")
+
+
+class SpeakerConfig(BaseModel):
+    """Configuration for a single speaker in speech generation."""
+    name: str = Field(..., description="The name of the speaker in the script (e.g., 'Joe', 'Narrator').")
+    voice: str = Field(..., description="The pre-built voice name to use (e.g., 'Kore', 'Puck', 'Chitose').")
+    # Gender is often inferred from the voice, but can be included for clarity
+    gender: Optional[str] = Field(None, description="The gender associated with the voice (e.g., 'Male', 'Female').")
+
+
+class SpeechGenerationPrompt(BaseModel):
+    """Input schema for generating speech from text."""
+    prompt: str = Field(
+        ...,
+        description="The text to be converted to speech. For multiple speakers, use their names (e.g., 'Joe: Hello. Jane: Hi there.')."
+    )
+    speakers: List[SpeakerConfig] = Field(
+        ...,
+        description="A list of speaker configurations. Use one for a single voice, multiple for a conversation."
+    )
+    model: Optional[str] = Field(default=None, description="The text-to-speech model to use.")
+    language: Optional[str] = Field("en-US", description="Language code for the conversation.")
+
+
+class VideoGenerationPrompt(BaseModel):
+    """Input schema for generating video content."""
+    prompt: str = Field(..., description="The text prompt describing the desired video content.")
+    number_of_videos: int = Field(
+        default=1, description="The number of videos to generated per request."
+    )
+    model: str = Field(..., description="The video generation model to use.")
+    aspect_ratio: str = Field(
+        default="16:9", description="The desired aspect ratio (e.g., '16:9', '9:16')."
+    )
+    duration: Optional[int] = Field(None, description="Optional duration in seconds for the video.")
+    negative_prompt: Optional[str] = Field(
+        default='',
+        description="A description of what to avoid in the video."
+    )
+
+class SentimentAnalysis(BaseModel):
+    """Structured sentiment analysis response."""
+    sentiment: Literal["positive", "negative", "neutral", "mixed"] = Field(
+        description="Overall sentiment classification"
+    )
+    confidence_level: float = Field(
+        ge=0.0, le=1.0,
+        description="Confidence level as decimal between 0 and 1"
+    )
+    emotional_indicators: List[str] = Field(
+        description="List of words/phrases that indicate emotional content"
+    )
+    reason: str = Field(
+        description="Explanation of the sentiment analysis"
+    )
+
+
+class ProductReview(BaseModel):
+    """Structured product review response."""
+    product_id: str = Field(..., description="Unique identifier for the product being reviewed")
+    product_name: str = Field(..., description="Name of the product being reviewed")
+    review_text: str = Field(..., description="The text of the product review")
+    rating: float = Field(..., description="Rating given to the product")
+    sentiment: Literal["positive", "negative", "neutral"] = Field(
+        ..., description="Sentiment of the review"
+    )
+    key_features: list[str] = Field(..., description="Key features highlighted in the review")