@weirdfingers/baseboards 0.4.1 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weirdfingers/baseboards",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "One-command launcher for the Boards image generation application",
   "type": "module",
   "bin": {

package/templates/api/config/generators.yaml

@@ -38,12 +38,21 @@ generators:
   - class: "boards.generators.implementations.fal.image.nano_banana.FalNanoBananaGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.image.nano_banana_pro.FalNanoBananaProGenerator"
+    enabled: true
+
   - class: "boards.generators.implementations.fal.video.sync_lipsync_v2.FalSyncLipsyncV2Generator"
     enabled: true
 
   - class: "boards.generators.implementations.fal.video.veo31_first_last_frame_to_video.FalVeo31FirstLastFrameToVideoGenerator"
     enabled: true
 
+  - class: "boards.generators.implementations.fal.video.veo31_image_to_video.FalVeo31ImageToVideoGenerator"
+    enabled: true
+
+  - class: "boards.generators.implementations.fal.video.veo31_reference_to_video.FalVeo31ReferenceToVideoGenerator"
+    enabled: true
+
   # OpenAI generators
   - class: "boards.generators.implementations.openai.image.dalle3.OpenAIDallE3Generator"
     enabled: true

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

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

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

@@ -4,7 +4,7 @@ Configuration management for Boards backend
 
 import os
 
-from pydantic_settings import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class Settings(BaseSettings):
@@ -85,13 +85,13 @@ class Settings(BaseSettings):
         ".json",  # Text
     ]
 
-    class Config:
-        env_file = ".env"
-        env_prefix = "BOARDS_"
-        case_sensitive = False
-
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_prefix="BOARDS_",
+        case_sensitive=False,
         # Allow extra fields for provider-specific configs
-        extra = "allow"
+        extra="allow",
+    )
 
 
 # Global settings instance

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

@@ -6,6 +6,7 @@ from .imagen4_preview import FalImagen4PreviewGenerator
 from .imagen4_preview_fast import FalImagen4PreviewFastGenerator
 from .nano_banana import FalNanoBananaGenerator
 from .nano_banana_edit import FalNanoBananaEditGenerator
+from .nano_banana_pro import FalNanoBananaProGenerator
 
 __all__ = [
     "FalFluxProKontextGenerator",
@@ -14,4 +15,5 @@ __all__ = [
     "FalImagen4PreviewFastGenerator",
     "FalNanoBananaGenerator",
     "FalNanoBananaEditGenerator",
+    "FalNanoBananaProGenerator",
 ]

package/templates/api/src/boards/generators/implementations/fal/image/nano_banana_pro.py

@@ -0,0 +1,179 @@
+"""
+fal.ai nano-banana-pro text-to-image generator.
+
+State-of-the-art image generation using Google's latest model, specializing in
+realism and typography applications.
+
+See: https://fal.ai/models/fal-ai/nano-banana-pro
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class NanoBananaProInput(BaseModel):
+    """Input schema for nano-banana-pro image generation."""
+
+    prompt: str = Field(
+        min_length=3,
+        max_length=50000,
+        description="The text prompt to generate an image from",
+    )
+    aspect_ratio: Literal[
+        "21:9",
+        "16:9",
+        "3:2",
+        "4:3",
+        "5:4",
+        "1:1",
+        "4:5",
+        "3:4",
+        "2:3",
+        "9:16",
+    ] = Field(
+        default="1:1",
+        description="Image aspect ratio",
+    )
+    num_images: int = Field(
+        default=1,
+        ge=1,
+        le=4,
+        description="Number of images to generate in batch",
+    )
+    resolution: Literal["1K", "2K", "4K"] = Field(
+        default="1K",
+        description="Image resolution (1K, 2K, or 4K)",
+    )
+    output_format: Literal["jpeg", "png", "webp"] = Field(
+        default="png",
+        description="Output image format",
+    )
+    sync_mode: bool = Field(
+        default=True,
+        description="Use synchronous mode (wait for completion)",
+    )
+
+
+class FalNanoBananaProGenerator(BaseGenerator):
+    """nano-banana-pro image generator using fal.ai.
+
+    Google's state-of-the-art image generation and editing model, specializing
+    in realism and typography applications.
+    """
+
+    name = "fal-nano-banana-pro"
+    artifact_type = "image"
+    description = (
+        "Fal: nano-banana-pro - Google's state-of-the-art image generation "
+        "with excellent realism and typography"
+    )
+
+    def get_input_schema(self) -> type[NanoBananaProInput]:
+        return NanoBananaProInput
+
+    async def generate(
+        self, inputs: NanoBananaProInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate images using fal.ai nano-banana-pro 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 NanoBananaProGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "aspect_ratio": inputs.aspect_ratio,
+            "num_images": inputs.num_images,
+            "resolution": inputs.resolution,
+            "output_format": inputs.output_format,
+            "sync_mode": inputs.sync_mode,
+        }
+
+        # Submit async job and get handler
+        handler = await fal_client.submit_async(
+            "fal-ai/nano-banana-pro",
+            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 image URLs from result
+        # fal.ai returns: {"images": [{"url": "...", "width": ..., "height": ...}, ...]}
+        images = result.get("images", [])
+        if not images:
+            raise ValueError("No images returned from fal.ai API")
+
+        # Store each image using output_index
+        artifacts = []
+        for idx, image_data in enumerate(images):
+            image_url = image_data.get("url")
+            width = image_data.get("width")
+            height = image_data.get("height")
+
+            if not image_url:
+                raise ValueError(f"Image {idx} missing URL in fal.ai response")
+
+            # Store with appropriate output_index
+            artifact = await context.store_image_result(
+                storage_url=image_url,
+                format=inputs.output_format,
+                width=width,
+                height=height,
+                output_index=idx,
+            )
+            artifacts.append(artifact)
+
+        return GeneratorResult(outputs=artifacts)
+
+    async def estimate_cost(self, inputs: NanoBananaProInput) -> float:
+        """Estimate cost for nano-banana-pro generation.
+
+        nano-banana-pro is a premium model costing approximately $0.039 per image.
+        """
+        return 0.039 * inputs.num_images  # $0.039 per image, scaled by batch size

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

@@ -5,9 +5,13 @@ from .kling_video_v2_5_turbo_pro_text_to_video import (
 )
 from .sync_lipsync_v2 import FalSyncLipsyncV2Generator
 from .veo31_first_last_frame_to_video import FalVeo31FirstLastFrameToVideoGenerator
+from .veo31_image_to_video import FalVeo31ImageToVideoGenerator
+from .veo31_reference_to_video import FalVeo31ReferenceToVideoGenerator
 
 __all__ = [
     "FalKlingVideoV25TurboProTextToVideoGenerator",
     "FalSyncLipsyncV2Generator",
     "FalVeo31FirstLastFrameToVideoGenerator",
+    "FalVeo31ImageToVideoGenerator",
+    "FalVeo31ReferenceToVideoGenerator",
 ]

package/templates/api/src/boards/generators/implementations/fal/video/veo31_image_to_video.py

@@ -0,0 +1,183 @@
+"""
+Google Veo 3.1 image-to-video generator.
+
+Converts static images into animated videos based on text prompts using
+Google's Veo 3.1 technology via fal.ai.
+
+Based on Fal AI's fal-ai/veo3.1/image-to-video model.
+See: https://fal.ai/models/fal-ai/veo3.1/image-to-video
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class Veo31ImageToVideoInput(BaseModel):
+    """Input schema for Veo 3.1 image-to-video generation.
+
+    Artifact fields (image) are automatically detected via type introspection
+    and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    prompt: str = Field(description="Text prompt describing the desired video content and motion")
+    image: ImageArtifact = Field(
+        description="Input image to animate. Should be 720p or higher in 16:9 or 9:16 aspect ratio"
+    )
+    aspect_ratio: Literal["9:16", "16:9"] = Field(
+        default="16:9",
+        description="Aspect ratio of the generated video",
+    )
+    duration: Literal["4s", "6s", "8s"] = Field(
+        default="8s",
+        description="Duration of the generated video in seconds",
+    )
+    generate_audio: bool = Field(
+        default=True,
+        description="Whether to generate audio for the video. Disabling uses 50% fewer credits",
+    )
+    resolution: Literal["720p", "1080p"] = Field(
+        default="720p",
+        description="Resolution of the generated video",
+    )
+
+
+class FalVeo31ImageToVideoGenerator(BaseGenerator):
+    """Generator for creating videos from static images using Google Veo 3.1."""
+
+    name = "fal-veo31-image-to-video"
+    description = "Fal: Veo 3.1 - Convert images to videos with text-guided animation"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[Veo31ImageToVideoInput]:
+        """Return the input schema for this generator."""
+        return Veo31ImageToVideoInput
+
+    async def generate(
+        self, inputs: Veo31ImageToVideoInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai veo3.1/image-to-video."""
+        # Check for API key
+        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 FalVeo31ImageToVideoGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image artifact to Fal's public storage
+        # Fal API requires publicly accessible URLs, but our storage_url might be:
+        # - Localhost URLs (not publicly accessible)
+        # - Private S3 buckets (not publicly accessible)
+        # So we upload to Fal's temporary storage first
+        from ..utils import upload_artifacts_to_fal
+
+        image_urls = await upload_artifacts_to_fal([inputs.image], context)
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "prompt": inputs.prompt,
+            "image_url": image_urls[0],
+            "aspect_ratio": inputs.aspect_ratio,
+            "duration": inputs.duration,
+            "generate_audio": inputs.generate_audio,
+            "resolution": inputs.resolution,
+        }
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/veo3.1/image-to-video",
+            arguments=arguments,
+        )
+
+        # Store external job ID
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for event in handler.iter_events(with_logs=True):
+            event_count += 1
+            # Sample every 3rd event to avoid spam
+            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,
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract video from result
+        # Expected structure: {"video": {"url": "...", "content_type": "...", ...}}
+        video_data = result.get("video")
+        if not video_data:
+            raise ValueError("No video returned from fal.ai API")
+
+        video_url = video_data.get("url")
+        if not video_url:
+            raise ValueError("Video missing URL in fal.ai response")
+
+        # Calculate video dimensions based on resolution and aspect ratio
+        if inputs.resolution == "720p":
+            if inputs.aspect_ratio == "16:9":
+                width, height = 1280, 720
+            else:  # 9:16
+                width, height = 720, 1280
+        else:  # 1080p
+            if inputs.aspect_ratio == "16:9":
+                width, height = 1920, 1080
+            else:  # 9:16
+                width, height = 1080, 1920
+
+        # Parse duration from "Xs" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=duration_seconds,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: Veo31ImageToVideoInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Note: Pricing information not available in Fal documentation.
+        Using placeholder value that should be updated with actual pricing.
+        """
+        # TODO: Update with actual pricing from Fal when available
+        # Base cost, with 50% reduction if audio is disabled
+        base_cost = 0.15  # Placeholder estimate
+        if not inputs.generate_audio:
+            return base_cost * 0.5
+        return base_cost

package/templates/api/src/boards/generators/implementations/fal/video/veo31_reference_to_video.py

@@ -0,0 +1,172 @@
+"""
+Google Veo 3.1 reference-to-video generator.
+
+Generates videos from multiple reference images to maintain consistent subject
+appearance while creating dynamic video content based on text prompts.
+
+Based on Fal AI's fal-ai/veo3.1/reference-to-video model.
+See: https://fal.ai/models/fal-ai/veo3.1/reference-to-video
+"""
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
+
+
+class Veo31ReferenceToVideoInput(BaseModel):
+    """Input schema for Veo 3.1 reference-to-video generation.
+
+    Artifact fields (image_urls) are automatically detected via type
+    introspection and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    image_urls: list[ImageArtifact] = Field(
+        description="URLs of reference images for consistent subject appearance"
+    )
+    prompt: str = Field(description="Text description of desired video content")
+    duration: Literal["8s"] = Field(
+        default="8s",
+        description="Duration of the generated video in seconds (currently only 8s is supported)",
+    )
+    resolution: Literal["720p", "1080p"] = Field(
+        default="720p",
+        description="Resolution of the generated video",
+    )
+    generate_audio: bool = Field(
+        default=True,
+        description="Whether to generate audio for the video. Disabling uses 50% fewer credits",
+    )
+
+
+class FalVeo31ReferenceToVideoGenerator(BaseGenerator):
+    """Generator for creating videos from reference images using Google Veo 3.1."""
+
+    name = "fal-veo31-reference-to-video"
+    description = "Fal: Veo 3.1 - Generate videos from reference images with consistent subjects"
+    artifact_type = "video"
+
+    def get_input_schema(self) -> type[Veo31ReferenceToVideoInput]:
+        """Return the input schema for this generator."""
+        return Veo31ReferenceToVideoInput
+
+    async def generate(
+        self, inputs: Veo31ReferenceToVideoInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using fal.ai veo3.1/reference-to-video."""
+        # Check for API key
+        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 FalVeo31ReferenceToVideoGenerator. "
+                "Install with: pip install weirdfingers-boards[generators-fal]"
+            ) from e
+
+        # Upload image artifacts to Fal's public storage
+        # Fal API requires publicly accessible URLs, but our storage_url might be:
+        # - Localhost URLs (not publicly accessible)
+        # - Private S3 buckets (not publicly accessible)
+        # So we upload to Fal's temporary storage first
+        from ..utils import upload_artifacts_to_fal
+
+        reference_image_urls = await upload_artifacts_to_fal(inputs.image_urls, context)
+
+        # Prepare arguments for fal.ai API
+        arguments = {
+            "image_urls": reference_image_urls,
+            "prompt": inputs.prompt,
+            "duration": inputs.duration,
+            "resolution": inputs.resolution,
+            "generate_audio": inputs.generate_audio,
+        }
+
+        # Submit async job
+        handler = await fal_client.submit_async(
+            "fal-ai/veo3.1/reference-to-video",
+            arguments=arguments,
+        )
+
+        # Store external job ID
+        await context.set_external_job_id(handler.request_id)
+
+        # Stream progress updates
+        from .....progress.models import ProgressUpdate
+
+        event_count = 0
+        async for event in handler.iter_events(with_logs=True):
+            event_count += 1
+            # Sample every 3rd event to avoid spam
+            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,
+                                phase="processing",
+                                message=message,
+                            )
+                        )
+
+        # Get final result
+        result = await handler.get()
+
+        # Extract video from result
+        # Expected structure: {"video": {"url": "...", "content_type": "...", ...}}
+        video_data = result.get("video")
+        if not video_data:
+            raise ValueError("No video returned from fal.ai API")
+
+        video_url = video_data.get("url")
+        if not video_url:
+            raise ValueError("Video missing URL in fal.ai response")
+
+        # Store video result
+        # Note: Fal API doesn't provide video dimensions/duration in the response,
+        # so we'll use defaults based on input parameters
+        width = 1280 if inputs.resolution == "720p" else 1920
+        height = 720 if inputs.resolution == "720p" else 1080
+
+        # Parse duration from "8s" format
+        duration_seconds = int(inputs.duration.rstrip("s"))
+
+        artifact = await context.store_video_result(
+            storage_url=video_url,
+            format="mp4",
+            width=width,
+            height=height,
+            duration=duration_seconds,
+            output_index=0,
+        )
+
+        return GeneratorResult(outputs=[artifact])
+
+    async def estimate_cost(self, inputs: Veo31ReferenceToVideoInput) -> float:
+        """Estimate cost for this generation in USD.
+
+        Note: Pricing information not available in Fal documentation.
+        Using placeholder value that should be updated with actual pricing.
+        """
+        # TODO: Update with actual pricing from Fal when available
+        # Base cost, with 50% reduction if audio is disabled
+        base_cost = 0.15  # Placeholder estimate
+        if not inputs.generate_audio:
+            return base_cost * 0.5
+        return base_cost

package/templates/api/src/boards/jobs/repository.py

@@ -115,7 +115,7 @@ async def create_batch_generation(
     input_params: dict,
     batch_id: str,
     batch_index: int,
-) -> Generations:
+) -> str:
     """Create a batch generation record for multi-output generators.
 
     This creates a new generation record that is part of a batch, with
@@ -133,7 +133,7 @@ async def create_batch_generation(
         batch_index: Index of this output in the batch
 
     Returns:
-        Created generation record
+        ID of the created generation record
     """
     gen = Generations()
     gen.tenant_id = tenant_id
@@ -150,4 +150,4 @@ async def create_batch_generation(
     }
     session.add(gen)
     await session.flush()
-    return gen
+    return str(gen.id)

package/templates/api/src/boards/workers/context.py

@@ -6,7 +6,12 @@ from uuid import UUID, uuid4
 
 from ..database.connection import get_async_session
 from ..generators import resolution
-from ..generators.artifacts import AudioArtifact, ImageArtifact, TextArtifact, VideoArtifact
+from ..generators.artifacts import (
+    AudioArtifact,
+    ImageArtifact,
+    TextArtifact,
+    VideoArtifact,
+)
 from ..jobs import repository as jobs_repo
 from ..logging import get_logger
 from ..progress.models import ProgressUpdate
@@ -319,7 +324,7 @@ class GeneratorExecutionContext:
 
         # Create new batch generation record
         async with get_async_session() as session:
-            batch_gen = await jobs_repo.create_batch_generation(
+            batch_gen_id = await jobs_repo.create_batch_generation(
                 session,
                 tenant_id=UUID(self.tenant_id),
                 board_id=UUID(self.board_id),
@@ -331,7 +336,6 @@ class GeneratorExecutionContext:
                 batch_index=output_index,
             )
             await session.commit()
-            batch_gen_id = str(batch_gen.id)
 
         self._batch_generations.append(batch_gen_id)
         logger.info(