@weirdfingers/baseboards 0.6.2 → 0.8.0

package/templates/api/config/generators.yaml

@@ -17,6 +17,12 @@ generators:
   - class: "boards.generators.implementations.fal.audio.beatoven_sound_effect_generation.FalBeatovenSoundEffectGenerationGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.audio.chatterbox_text_to_speech.FalChatterboxTextToSpeechGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.audio.chatterbox_tts_turbo.FalChatterboxTtsTurboGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.image.clarity_upscaler.FalClarityUpscalerGenerator"
     enabled: true
 
@@ -32,6 +38,9 @@ generators:
   - class: "boards.generators.implementations.fal.video.bytedance_seedance_v1_pro_text_to_video.FalBytedanceSeedanceV1ProTextToVideoGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.image.bytedance_seedream_v45_edit.FalBytedanceSeedreamV45EditGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.audio.elevenlabs_tts_eleven_v3.FalElevenlabsTtsElevenV3Generator"
     enabled: true
 
@@ -59,12 +68,21 @@ generators:
   - class: "boards.generators.implementations.fal.image.gemini_25_flash_image.FalGemini25FlashImageGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.image.gemini_25_flash_image_edit.FalGemini25FlashImageEditGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.image.gpt_image_1_5.FalGptImage15Generator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.image.gpt_image_1_edit_image.FalGptImage1EditImageGenerator"
     enabled: true
 
   - class: "boards.generators.implementations.fal.image.gpt_image_1_mini.FalGptImage1MiniGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.image.gpt_image_15_edit.FalGptImage15EditGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.image.fal_ideogram_character.FalIdeogramCharacterGenerator"
     enabled: true
 
@@ -86,6 +104,12 @@ generators:
   - class: "boards.generators.implementations.fal.video.infinitalk.FalInfinitalkGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.video.kling_video_ai_avatar_v2_pro.FalKlingVideoAiAvatarV2ProGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.video.kling_video_ai_avatar_v2_standard.FalKlingVideoAiAvatarV2StandardGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.kling_video_v2_5_turbo_pro_image_to_video.FalKlingVideoV25TurboProImageToVideoGenerator"
     enabled: true
 
@@ -128,6 +152,15 @@ generators:
   - class: "boards.generators.implementations.fal.image.qwen_image.FalQwenImageGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.image.reve_edit.FalReveEditGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.image.reve_text_to_image.FalReveTextToImageGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.image.seedream_v45_text_to_image.FalSeedreamV45TextToImageGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.sora_2_text_to_video_pro.FalSora2TextToVideoProGenerator"
     enabled: true
 
@@ -143,6 +176,9 @@ generators:
   - class: "boards.generators.implementations.fal.video.sync_lipsync_v2.FalSyncLipsyncV2Generator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.video.veed_fabric_1_0.FalVeedFabric10Generator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.veed_lipsync.FalVeedLipsyncGenerator"
     enabled: true
 
@@ -152,6 +188,15 @@ generators:
   - class: "boards.generators.implementations.fal.video.veo3.FalVeo3Generator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.video.veo31.FalVeo31Generator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.video.veo31_fast.FalVeo31FastGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.video.veo31_fast_image_to_video.FalVeo31FastImageToVideoGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.veo31_first_last_frame_to_video.FalVeo31FirstLastFrameToVideoGenerator"
     enabled: true
 
@@ -161,9 +206,22 @@ generators:
   - class: "boards.generators.implementations.fal.video.veo31_reference_to_video.FalVeo31ReferenceToVideoGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.video.wan_25_preview_image_to_video.FalWan25PreviewImageToVideoGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.video.wan_25_preview_text_to_video.FalWan25PreviewTextToVideoGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.wan_pro_image_to_video.FalWanProImageToVideoGenerator"
     enabled: true
 
+  # Kie.ai generators
+  - class: "boards.generators.implementations.kie.image.nano_banana_edit.KieNanoBananaEditGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.kie.video.veo3.KieVeo3Generator"
+    enabled: true
+
   # OpenAI generators
   - class: "boards.generators.implementations.openai.image.dalle3.OpenAIDallE3Generator"
     enabled: true

package/templates/api/pyproject.toml

@@ -46,7 +46,7 @@ dependencies = [
     "dramatiq[redis,watch]>=1.15.0",
     "pillow>=10.0.0",
     "numpy>=1.24.0",
-    "psycopg2-binary>=2.9.0",
+    "psycopg[binary]>=3.1.0",
     "structlog>=23.0.0",
     "asyncpg>=0.29.0",
     "alembic>=1.13.2",

package/templates/api/src/boards/__init__.py

@@ -3,7 +3,7 @@ Boards Backend SDK
 Open-source creative toolkit for AI-generated content
 """
 
-__version__ = "0.6.2"
+__version__ = "0.8.0"
 
 from .config import settings
 

package/templates/api/src/boards/api/endpoints/storage.py

@@ -21,15 +21,57 @@ async def storage_status():
     return {"status": "Storage endpoint ready"}
 
 
+def _get_extension_from_content_type(content_type: str) -> str:
+    """Get file extension from content type.
+
+    Args:
+        content_type: MIME type (e.g., 'video/mp4', 'image/png', 'audio/mpeg')
+
+    Returns:
+        File extension with dot (e.g., '.mp4', '.png', '.mp3')
+    """
+    # Map common content types to extensions
+    content_type_map = {
+        # Video
+        "video/mp4": ".mp4",
+        "video/webm": ".webm",
+        "video/quicktime": ".mov",
+        "video/x-msvideo": ".avi",
+        # Image
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/jpg": ".jpg",
+        "image/webp": ".webp",
+        "image/gif": ".gif",
+        # Audio
+        "audio/mpeg": ".mp3",
+        "audio/mp3": ".mp3",
+        "audio/wav": ".wav",
+        "audio/ogg": ".ogg",
+        "audio/aac": ".aac",
+        # Text
+        "text/plain": ".txt",
+        "text/html": ".html",
+    }
+
+    return content_type_map.get(content_type.lower(), "")
+
+
 @router.get("/{full_path:path}")
-async def serve_file(full_path: str):
+async def serve_file(full_path: str, download: bool = False, filename: str | None = None):
     """Serve a file from local storage.
 
     This endpoint serves files that were uploaded to local storage.
     The full_path includes the tenant_id/artifact_type/board_id/artifact_id/variant structure.
+
+    Args:
+        full_path: Path to the file in storage
+        download: If True, force download with Content-Disposition: attachment
+        filename: Optional custom filename (without extension) to use for download
     """
     try:
-        logger.info("Serving file", full_path=full_path)
+        logger.info("Serving file", full_path=full_path, download=download, filename=filename)
+
         # Create storage manager to get the configured local storage path
         storage_manager = create_storage_manager()
 
@@ -64,8 +106,47 @@ async def serve_file(full_path: str):
         if not file_path.is_file():
             raise HTTPException(status_code=400, detail="Path is not a file")
 
-        # Serve the file
-        return FileResponse(file_path)
+        # Determine the proper filename with extension
+        base_filename = filename if filename else file_path.stem
+        final_filename = file_path.name
+        has_extension = False
+
+        # Try to get metadata from storage to determine content type and proper extension
+        try:
+            metadata = await local_provider.get_metadata(full_path)
+            content_type = metadata.get("content_type")
+
+            if content_type:
+                extension = _get_extension_from_content_type(content_type)
+                if extension:
+                    # Use custom filename if provided, otherwise use file stem
+                    final_filename = f"{base_filename}{extension}"
+                    has_extension = True
+                    logger.info(
+                        "Determined filename from storage metadata",
+                        original=file_path.name,
+                        new_filename=final_filename,
+                        content_type=content_type,
+                        custom_filename=filename,
+                    )
+        except Exception as e:
+            # Log but don't fail if we can't get metadata
+            logger.warning("Failed to get storage metadata", path=full_path, error=str(e))
+
+        # Serve the file with proper filename
+        # Only set Content-Disposition if:
+        # 1. Download is explicitly requested, OR
+        # 2. We have a proper extension from metadata
+        headers = {}
+        if download:
+            # Force download with attachment
+            headers["Content-Disposition"] = f'attachment; filename="{final_filename}"'
+        elif has_extension:
+            # We have proper metadata, suggest filename but allow inline preview
+            headers["Content-Disposition"] = f'inline; filename="{final_filename}"'
+        # else: No Content-Disposition header - let browser decide based on content-type
+
+        return FileResponse(file_path, filename=final_filename, headers=headers)
 
     except HTTPException:
         raise

package/templates/api/src/boards/api/endpoints/uploads.py

@@ -86,8 +86,7 @@ async def upload_artifact_file(
         raise HTTPException(
             status_code=400,
             detail=(
-                f"File extension '{file_ext}' is not allowed. "
-                f"Allowed extensions: {allowed_exts}"
+                f"File extension '{file_ext}' is not allowed. Allowed extensions: {allowed_exts}"
             ),
         )
 

package/templates/api/src/boards/database/connection.py

@@ -8,7 +8,12 @@ from collections.abc import AsyncGenerator, Generator
 from contextlib import asynccontextmanager, contextmanager
 
 from sqlalchemy import create_engine, text
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
 from sqlalchemy.orm import Session, sessionmaker
 
 from ..config import settings
@@ -18,11 +23,25 @@ logger = get_logger(__name__)
 
 # Global shared connection pools (proper FastAPI pattern)
 _engine = None
-_async_engine = None
 _session_local = None
-_async_session_local = None
-_initialized = False
-_init_lock = threading.Lock()  # Protect initialization from race conditions
+_sync_initialized = False
+_sync_init_lock = threading.Lock()
+
+
+class AsyncDBContext(threading.local):
+    engine: AsyncEngine | None
+    initialized: bool
+    session_local: async_sessionmaker[AsyncSession] | None
+    lock: threading.Lock
+
+    def __init__(self):
+        self.engine = None
+        self.initialized = False
+        self.session_local = None
+        self.lock = threading.Lock()  # Per-thread lock for async initialization
+
+
+_async_db_ctx = AsyncDBContext()
 
 
 def get_database_url() -> str:
@@ -40,12 +59,22 @@ def get_database_url() -> str:
 
 def reset_database():
     """Reset database connections (for tests)."""
-    global _engine, _async_engine, _session_local, _async_session_local, _initialized
+    global _engine, _session_local, _sync_initialized
+
+    # Dispose of sync engine if it exists
+    if _engine is not None:
+        _engine.dispose()
+
     _engine = None
-    _async_engine = None
     _session_local = None
-    _async_session_local = None
-    _initialized = False
+    _sync_initialized = False
+
+    # Reset async context for current thread
+    # Note: async engine disposal must be done with await, so we just clear the reference
+    # The engine will be garbage collected when no sessions reference it
+    _async_db_ctx.engine = None
+    _async_db_ctx.session_local = None
+    _async_db_ctx.initialized = False
 
 
 async def test_database_connection() -> tuple[bool, str | None]:
@@ -55,11 +84,11 @@ async def test_database_connection() -> tuple[bool, str | None]:
     Returns:
         tuple: (success: bool, error_message: str | None)
     """
-    if _async_engine is None:
+    if _async_db_ctx.engine is None:
         return False, "Database engine not initialized"
 
     try:
-        async with _async_engine.connect() as conn:
+        async with _async_db_ctx.engine.connect() as conn:
             await conn.execute(text("SELECT 1"))
             return True, None
     except Exception as e:
@@ -101,48 +130,59 @@ def init_database(database_url: str | None = None, force_reinit: bool = False):
     Thread-safe initialization using a lock to prevent race conditions
     when multiple threads attempt to initialize simultaneously.
     """
-    global _engine, _async_engine, _session_local, _async_session_local, _initialized
-
-    # Fast path: already initialized, no lock needed
-    if _initialized and not force_reinit and database_url is None:
-        return
-
-    # Slow path: acquire lock for initialization
-    with _init_lock:
-        # Double-check after acquiring lock (another thread may have initialized)
-        if _initialized and not force_reinit and database_url is None:
-            return
-
-        # Get the database URL
-        db_url = database_url or get_database_url()
-
-        # Create sync engine
-        _engine = create_engine(
-            db_url,
-            pool_size=settings.database_pool_size,
-            max_overflow=settings.database_max_overflow,
-            echo=settings.sql_echo,
-        )
-        _session_local = sessionmaker(autocommit=False, autoflush=False, bind=_engine)
-
-        # Create async engine (if PostgreSQL)
-        if db_url.startswith("postgresql://"):
-            async_db_url = db_url.replace("postgresql://", "postgresql+asyncpg://")
-            _async_engine = create_async_engine(
-                async_db_url,
-                pool_size=settings.database_pool_size,
-                max_overflow=settings.database_max_overflow,
-                echo=settings.sql_echo,
-            )
-            _async_session_local = async_sessionmaker(
-                _async_engine,
-                class_=AsyncSession,
-                autocommit=False,
-                autoflush=False,
-            )
-
-        _initialized = True
-        logger.info("Database initialized", database_url=db_url)
+    global _engine, _session_local, _sync_initialized
+
+    # Get the database URL
+    db_url = database_url or get_database_url()
+
+    # Initialize Sync Engine (Global)
+    if not _sync_initialized or force_reinit:
+        with _sync_init_lock:
+            if not _sync_initialized or force_reinit:
+                sync_db_url = db_url
+                if db_url.startswith("postgresql://"):
+                    sync_db_url = db_url.replace("postgresql://", "postgresql+psycopg://")
+                _engine = create_engine(
+                    url=sync_db_url,
+                    pool_size=settings.database_pool_size,
+                    max_overflow=settings.database_max_overflow,
+                    echo=settings.sql_echo,
+                )
+                _session_local = sessionmaker(autocommit=False, autoflush=False, bind=_engine)
+                _sync_initialized = True
+                logger.info("Sync database initialized", database_url=db_url)
+
+    # Initialize Async Engine (Thread-Local)
+    # Async engines must be thread-local because asyncpg connections are tied to the event loop
+    # and cannot be shared across threads/loops.
+    if not _async_db_ctx.initialized or force_reinit:
+        with _async_db_ctx.lock:
+            # Double-check after acquiring lock (another coroutine may have initialized)
+            if not _async_db_ctx.initialized or force_reinit:
+                if db_url.startswith("postgresql://"):
+                    async_db_url = db_url.replace("postgresql://", "postgresql+asyncpg://")
+                    _async_db_ctx.engine = create_async_engine(
+                        url=async_db_url,
+                        pool_size=settings.database_pool_size,
+                        max_overflow=settings.database_max_overflow,
+                        echo=settings.sql_echo,
+                    )
+                    _async_db_ctx.session_local = async_sessionmaker(
+                        _async_db_ctx.engine,
+                        class_=AsyncSession,
+                        autocommit=False,
+                        autoflush=False,
+                    )
+                    _async_db_ctx.initialized = True
+                    logger.info(
+                        "Async database initialized for thread",
+                        thread_id=threading.get_ident(),
+                    )
+                else:
+                    logger.warning(
+                        "Non-PostgreSQL URL detected, async engine not initialized",
+                        url_prefix=db_url.split("://")[0] if "://" in db_url else "unknown",
+                    )
 
 
 def get_engine():
@@ -154,9 +194,9 @@ def get_engine():
 
 def get_async_engine():
     """Get the shared async SQLAlchemy engine."""
-    if _async_engine is None:
+    if _async_db_ctx.engine is None:
         init_database()
-    return _async_engine
+    return _async_db_ctx.engine
 
 
 @contextmanager
@@ -182,13 +222,13 @@ def get_session() -> Generator[Session, None, None]:
 @asynccontextmanager
 async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
     """Get a database session (async) from shared pool."""
-    if _async_session_local is None:
+    if _async_db_ctx.session_local is None:
         init_database()
 
-    if _async_session_local is None:
+    if _async_db_ctx.session_local is None:
         raise RuntimeError("Async database not available (PostgreSQL required)")
 
-    async with _async_session_local() as session:
+    async with _async_db_ctx.session_local() as session:
         try:
             yield session
             await session.commit()

package/templates/api/src/boards/generators/implementations/fal/audio/__init__.py

@@ -1,5 +1,7 @@
 from .beatoven_music_generation import FalBeatovenMusicGenerationGenerator
 from .beatoven_sound_effect_generation import FalBeatovenSoundEffectGenerationGenerator
+from .chatterbox_text_to_speech import FalChatterboxTextToSpeechGenerator
+from .chatterbox_tts_turbo import FalChatterboxTtsTurboGenerator
 from .elevenlabs_sound_effects_v2 import FalElevenlabsSoundEffectsV2Generator
 from .elevenlabs_tts_eleven_v3 import FalElevenlabsTtsElevenV3Generator
 from .fal_elevenlabs_tts_turbo_v2_5 import FalElevenlabsTtsTurboV25Generator
@@ -10,6 +12,8 @@ from .minimax_speech_2_6_turbo import FalMinimaxSpeech26TurboGenerator
 __all__ = [
     "FalBeatovenMusicGenerationGenerator",
     "FalBeatovenSoundEffectGenerationGenerator",
+    "FalChatterboxTextToSpeechGenerator",
+    "FalChatterboxTtsTurboGenerator",
     "FalElevenlabsSoundEffectsV2Generator",
     "FalElevenlabsTtsElevenV3Generator",
     "FalElevenlabsTtsTurboV25Generator",

package/templates/api/src/boards/generators/implementations/fal/audio/chatterbox_text_to_speech.py

@@ -0,0 +1,176 @@
+"""
+fal.ai Chatterbox Text-to-Speech generator.
+
+Generate expressive speech from text using Resemble AI's Chatterbox model.
+Supports emotive tags for natural expressions like laughing, sighing, and more.
+
+Based on Fal AI's fal-ai/chatterbox/text-to-speech model.
+See: https://fal.ai/models/fal-ai/chatterbox/text-to-speech
+"""
+
+import os
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class ChatterboxTextToSpeechInput(BaseModel):
+    """Input schema for Chatterbox text-to-speech generation.
+
+    Supports emotive tags: <laugh>, <chuckle>, <sigh>, <cough>,
+    <sniffle>, <groan>, <yawn>, <gasp>
+    """
+
+    text: str = Field(
+        description=(
+            "The text to be converted to speech. You can add emotive tags like "
+            "<laugh>, <chuckle>, <sigh>, <cough>, <sniffle>, <groan>, <yawn>, <gasp>"
+        ),
+        min_length=1,
+    )
+    audio_url: str | None = Field(
+        default=None,
+        description=(
+            "Reference audio file URL for voice style matching. "
+            "If not provided, uses a default voice sample."
+        ),
+    )
+    exaggeration: float = Field(
+        default=0.25,
+        ge=0.0,
+        le=1.0,
+        description="Speech exaggeration intensity factor (0.0 to 1.0)",
+    )
+    temperature: float = Field(
+        default=0.7,
+        ge=0.05,
+        le=2.0,
+        description="Creativity level for generation (0.05 to 2.0)",
+    )
+    cfg: float = Field(
+        default=0.5,
+        ge=0.1,
+        le=1.0,
+        description="Configuration parameter for generation (0.1 to 1.0)",
+    )
+    seed: int | None = Field(
+        default=None,
+        description="Random seed for reproducible audio generation",
+    )
+
+
+class FalChatterboxTextToSpeechGenerator(BaseGenerator):
+    """Chatterbox text-to-speech generator using fal.ai.
+
+    Leverages Resemble AI's Chatterbox model to generate expressive speech
+    with support for emotive tags and voice cloning via reference audio.
+    """
+
+    name = "fal-chatterbox-text-to-speech"
+    artifact_type = "audio"
+    description = (
+        "Fal: Chatterbox TTS - Expressive text-to-speech with emotive tags and voice cloning"
+    )
+
+    def get_input_schema(self) -> type[ChatterboxTextToSpeechInput]:
+        return ChatterboxTextToSpeechInput
+
+    async def generate(
+        self, inputs: ChatterboxTextToSpeechInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate audio using fal.ai Chatterbox text-to-speech model."""
+        # Check for API key (fal-client uses FAL_KEY environment variable)
+        if not os.getenv("FAL_KEY"):
+            raise ValueError("API configuration invalid. Missing FAL_KEY environment variable")
+
+        # Import fal_client
+        try:
+            import fal_client
+        except ImportError as e:
+            raise ImportError(
+                "fal.ai SDK is required for FalChatterboxTextToSpeechGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments: dict = {
+            "text": inputs.text,
+            "exaggeration": inputs.exaggeration,
+            "temperature": inputs.temperature,
+            "cfg": inputs.cfg,
+        }
+
+        # Add optional parameters if provided
+        if inputs.audio_url is not None:
+            arguments["audio_url"] = inputs.audio_url
+        if inputs.seed is not None:
+            arguments["seed"] = inputs.seed
+
+        # Submit async job and get handler
+        handler = await fal_client.submit_async(
+            "fal-ai/chatterbox/text-to-speech",
+            arguments=arguments,
+        )
+
+        # Store the external job ID for tracking
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates (sample every 3rd event to avoid spam)
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for event in handler.iter_events(with_logs=True):
+            event_count += 1
+
+            # Process every 3rd event to provide feedback without overwhelming
+            if event_count % 3 == 0:
+                # Extract logs if available
+                logs = getattr(event, "logs", None)
+                if logs:
+                    # Join log entries into a single message
+                    if isinstance(logs, list):
+                        message = " | ".join(str(log) for log in logs if log)
+                    else:
+                        message = str(logs)
+
+                    if message:
+                        await context.publish_progress(
+                            ProgressUpdate(
+                                job_id=handler.request_id,
+                                status="processing",
+                                progress=50.0,  # Approximate mid-point progress
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract audio URL from result
+        # fal.ai returns: {"audio": {"url": "..."}}
+        audio_data = result.get("audio")
+        if audio_data is None:
+            raise ValueError("No audio data returned from fal.ai API")
+
+        audio_url = audio_data.get("url")
+        if not audio_url:
+            raise ValueError("Audio URL missing in fal.ai response")
+
+        # Store audio result
+        artifact = await context.store_audio_result(
+            storage_url=audio_url,
+            format="mp3",  # Chatterbox returns MP3 format
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: ChatterboxTextToSpeechInput) -> float:
+        """Estimate cost for Chatterbox text-to-speech generation.
+
+        Chatterbox pricing is approximately $0.03 per generation.
+        """
+        # Fixed cost per generation
+        return 0.03