@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,180 +0,0 @@
-"""
-Generate high-quality images using ByteDance's Seedream 4.5 text-to-image model.
-
-Based on Fal AI's fal-ai/bytedance/seedream/v4.5/text-to-image model.
-See: https://fal.ai/models/fal-ai/bytedance/seedream/v4.5/text-to-image
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class SeedreamV45TextToImageInput(BaseModel):
-    """Input schema for Seedream V4.5 text-to-image generation.
-
-    Seedream 4.5 is ByteDance's new-generation image creation model that integrates
-    image generation and editing capabilities into a unified architecture.
-    """
-
-    prompt: str = Field(description="The text prompt used to generate the image")
-    num_images: int = Field(
-        default=1,
-        ge=1,
-        le=6,
-        description="Number of images to generate",
-    )
-    image_size: (
-        Literal[
-            "square_hd",
-            "portrait_4_3",
-            "landscape_16_9",
-            "auto_2K",
-            "auto_4K",
-        ]
-        | None
-    ) = Field(
-        default=None,
-        description=(
-            "The size preset for the generated image. Options include "
-            "square_hd, portrait_4_3, landscape_16_9, auto_2K, auto_4K"
-        ),
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Enable or disable the safety checker",
-    )
-
-
-class FalSeedreamV45TextToImageGenerator(BaseGenerator):
-    """Generator for high-quality images using ByteDance's Seedream 4.5 model."""
-
-    name = "fal-seedream-v45-text-to-image"
-    artifact_type = "image"
-    description = "Fal: ByteDance Seedream 4.5 - high-quality text-to-image generation"
-
-    def get_input_schema(self) -> type[SeedreamV45TextToImageInput]:
-        """Return the input schema for this generator."""
-        return SeedreamV45TextToImageInput
-
-    async def generate(
-        self, inputs: SeedreamV45TextToImageInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate images using fal.ai ByteDance Seedream 4.5 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 FalSeedreamV45TextToImageGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Prepare arguments for fal.ai API
-        arguments: dict[str, object] = {
-            "prompt": inputs.prompt,
-            "num_images": inputs.num_images,
-            "enable_safety_checker": inputs.enable_safety_checker,
-        }
-
-        # Add optional parameters
-        if inputs.image_size is not None:
-            arguments["image_size"] = inputs.image_size
-
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job and get handler
-        handler = await fal_client.submit_async(
-            "fal-ai/bytedance/seedream/v4.5/text-to-image",
-            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 data from result
-        # fal.ai seedream returns:
-        # {"images": [{"url": "...", "width": ..., "height": ..., ...}], "seed": ...}
-        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")
-
-            if not image_url:
-                raise ValueError(f"Image {idx} missing URL in fal.ai response")
-
-            # Extract dimensions if available, use defaults otherwise
-            width = image_data.get("width", 2048)
-            height = image_data.get("height", 2048)
-
-            # Determine format from content_type (e.g., "image/png" -> "png")
-            content_type = image_data.get("content_type", "image/png")
-            format = content_type.split("/")[-1] if "/" in content_type else "png"
-
-            # Store with appropriate output_index
-            artifact = await context.store_image_result(
-                storage_url=image_url,
-                format=format,
-                width=width,
-                height=height,
-                output_index=idx,
-            )
-            artifacts.append(artifact)
-
-        return GeneratorResult(outputs=artifacts)
-
-    async def estimate_cost(self, inputs: SeedreamV45TextToImageInput) -> float:
-        """Estimate cost for Seedream V4.5 generation.
-
-        Seedream V4.5 pricing is approximately $0.03 per image generation.
-        Note: Actual pricing may vary. Check Fal AI documentation for current rates.
-        """
-        return 0.03 * inputs.num_images

package/templates/api/src/boards/generators/implementations/fal/utils.py

@@ -1,61 +0,0 @@
-"""
-Shared utilities for Fal.ai generators.
-
-Provides helper functions for common operations across Fal generators.
-"""
-
-import asyncio
-
-from ...artifacts import AudioArtifact, DigitalArtifact, ImageArtifact, VideoArtifact
-from ...base import GeneratorExecutionContext
-
-
-async def upload_artifacts_to_fal[T: DigitalArtifact](
-    artifacts: list[ImageArtifact] | list[VideoArtifact] | list[AudioArtifact] | list[T],
-    context: GeneratorExecutionContext,
-) -> list[str]:
-    """
-    Upload artifacts to Fal's temporary storage for use in API requests.
-
-    Fal API endpoints require publicly accessible URLs for file inputs. Since our
-    storage URLs might be local or private (localhost, private S3 buckets, etc.),
-    we need to:
-    1. Resolve each artifact to a local file path
-    2. Upload to Fal's public temporary storage
-    3. Get back publicly accessible URLs
-
-    Args:
-        artifacts: List of artifacts (image, video, or audio) to upload
-        context: Generator execution context for artifact resolution
-
-    Returns:
-        List of publicly accessible URLs from Fal storage
-
-    Raises:
-        ImportError: If fal_client is not installed
-        Any exceptions from file resolution or upload are propagated
-    """
-    # Import fal_client
-    try:
-        import fal_client
-    except ImportError as e:
-        raise ImportError(
-            "fal.ai SDK is required for Fal generators. "
-            "Install with: pip install weirdfingers-boards[generators-fal]"
-        ) from e
-
-    async def upload_single_artifact(artifact: DigitalArtifact) -> str:
-        """Upload a single artifact and return its public URL."""
-        # Resolve artifact to local file path (downloads if needed)
-        file_path_str = await context.resolve_artifact(artifact)
-
-        # Upload to Fal's temporary storage and get public URL
-        # fal_client.upload_file_async expects a file path
-        url = await fal_client.upload_file_async(file_path_str)  # type: ignore[arg-type]
-
-        return url
-
-    # Upload all artifacts in parallel for performance
-    urls = await asyncio.gather(*[upload_single_artifact(artifact) for artifact in artifacts])
-
-    return list(urls)

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

@@ -1,77 +0,0 @@
-"""Fal.ai video generators."""
-
-from .bytedance_seedance_v1_pro_text_to_video import (
-    FalBytedanceSeedanceV1ProTextToVideoGenerator,
-)
-from .creatify_lipsync import FalCreatifyLipsyncGenerator
-from .fal_bytedance_seedance_v1_pro_image_to_video import (
-    FalBytedanceSeedanceV1ProImageToVideoGenerator,
-)
-from .fal_minimax_hailuo_02_standard_text_to_video import (
-    FalMinimaxHailuo02StandardTextToVideoGenerator,
-)
-from .fal_pixverse_lipsync import FalPixverseLipsyncGenerator
-from .fal_sora_2_text_to_video import FalSora2TextToVideoGenerator
-from .infinitalk import FalInfinitalkGenerator
-from .kling_video_ai_avatar_v2_pro import FalKlingVideoAiAvatarV2ProGenerator
-from .kling_video_ai_avatar_v2_standard import (
-    FalKlingVideoAiAvatarV2StandardGenerator,
-)
-from .kling_video_v2_5_turbo_pro_image_to_video import (
-    FalKlingVideoV25TurboProImageToVideoGenerator,
-)
-from .kling_video_v2_5_turbo_pro_text_to_video import (
-    FalKlingVideoV25TurboProTextToVideoGenerator,
-)
-from .minimax_hailuo_2_3_pro_image_to_video import (
-    FalMinimaxHailuo23ProImageToVideoGenerator,
-)
-from .sora2_image_to_video import FalSora2ImageToVideoGenerator
-from .sora_2_image_to_video_pro import FalSora2ImageToVideoProGenerator
-from .sora_2_text_to_video_pro import FalSora2TextToVideoProGenerator
-from .sync_lipsync_v2 import FalSyncLipsyncV2Generator
-from .sync_lipsync_v2_pro import FalSyncLipsyncV2ProGenerator
-from .veed_fabric_1_0 import FalVeedFabric10Generator
-from .veed_lipsync import FalVeedLipsyncGenerator
-from .veo3 import FalVeo3Generator
-from .veo31 import FalVeo31Generator
-from .veo31_fast import FalVeo31FastGenerator
-from .veo31_fast_image_to_video import FalVeo31FastImageToVideoGenerator
-from .veo31_first_last_frame_to_video import FalVeo31FirstLastFrameToVideoGenerator
-from .veo31_image_to_video import FalVeo31ImageToVideoGenerator
-from .veo31_reference_to_video import FalVeo31ReferenceToVideoGenerator
-from .wan_25_preview_image_to_video import FalWan25PreviewImageToVideoGenerator
-from .wan_25_preview_text_to_video import FalWan25PreviewTextToVideoGenerator
-from .wan_pro_image_to_video import FalWanProImageToVideoGenerator
-
-__all__ = [
-    "FalInfinitalkGenerator",
-    "FalCreatifyLipsyncGenerator",
-    "FalBytedanceSeedanceV1ProImageToVideoGenerator",
-    "FalBytedanceSeedanceV1ProTextToVideoGenerator",
-    "FalKlingVideoAiAvatarV2ProGenerator",
-    "FalKlingVideoAiAvatarV2StandardGenerator",
-    "FalKlingVideoV25TurboProImageToVideoGenerator",
-    "FalKlingVideoV25TurboProTextToVideoGenerator",
-    "FalPixverseLipsyncGenerator",
-    "FalSora2TextToVideoProGenerator",
-    "FalSora2TextToVideoGenerator",
-    "FalMinimaxHailuo02StandardTextToVideoGenerator",
-    "FalMinimaxHailuo23ProImageToVideoGenerator",
-    "FalSora2ImageToVideoGenerator",
-    "FalSora2ImageToVideoProGenerator",
-    "FalSyncLipsyncV2Generator",
-    "FalVeedFabric10Generator",
-    "FalVeedLipsyncGenerator",
-    "FalSyncLipsyncV2ProGenerator",
-    "FalVeo3Generator",
-    "FalVeo31Generator",
-    "FalVeo31FastGenerator",
-    "FalVeo31FastImageToVideoGenerator",
-    "FalVeo31FirstLastFrameToVideoGenerator",
-    "FalVeo31ImageToVideoGenerator",
-    "FalVeo31ReferenceToVideoGenerator",
-    "FalWan25PreviewImageToVideoGenerator",
-    "FalWan25PreviewTextToVideoGenerator",
-    "FalWanProImageToVideoGenerator",
-]

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

@@ -1,209 +0,0 @@
-"""
-Bytedance Seedance 1.0 Pro text-to-video generator.
-
-A high quality video generation model developed by Bytedance that transforms
-text prompts into professional-grade videos with customizable parameters.
-
-Based on Fal AI's fal-ai/bytedance/seedance/v1/pro/text-to-video model.
-See: https://fal.ai/models/fal-ai/bytedance/seedance/v1/pro/text-to-video
-"""
-
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class BytedanceSeedanceV1ProTextToVideoInput(BaseModel):
-    """Input schema for Bytedance Seedance 1.0 Pro text-to-video generation."""
-
-    prompt: str = Field(
-        description="Text description of the desired video content",
-    )
-    aspect_ratio: Literal["21:9", "16:9", "4:3", "1:1", "3:4", "9:16"] = Field(
-        default="16:9",
-        description="Video aspect ratio",
-    )
-    resolution: Literal["480p", "720p", "1080p"] = Field(
-        default="1080p",
-        description="Video resolution quality",
-    )
-    duration: Literal["2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"] = Field(
-        default="5",
-        description="Video length in seconds (2-12)",
-    )
-    enable_safety_checker: bool = Field(
-        default=True,
-        description="Enable safety checker to filter unsafe content",
-    )
-    camera_fixed: bool = Field(
-        default=False,
-        description="Whether to fix camera position during generation",
-    )
-    seed: int | None = Field(
-        default=None,
-        description="Random seed for reproducibility; use -1 for randomization",
-    )
-
-
-class FalBytedanceSeedanceV1ProTextToVideoGenerator(BaseGenerator):
-    """Generator for text-to-video using Bytedance Seedance 1.0 Pro."""
-
-    name = "fal-bytedance-seedance-v1-pro-text-to-video"
-    description = "Fal: Bytedance Seedance 1.0 Pro - high quality text-to-video generation"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[BytedanceSeedanceV1ProTextToVideoInput]:
-        """Return the input schema for this generator."""
-        return BytedanceSeedanceV1ProTextToVideoInput
-
-    async def generate(
-        self, inputs: BytedanceSeedanceV1ProTextToVideoInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate video using fal.ai Bytedance Seedance 1.0 Pro model."""
-        # 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 FalBytedanceSeedanceV1ProTextToVideoGenerator. "
-                "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,
-            "resolution": inputs.resolution,
-            "duration": inputs.duration,
-            "enable_safety_checker": inputs.enable_safety_checker,
-            "camera_fixed": inputs.camera_fixed,
-        }
-
-        # Add seed if provided
-        if inputs.seed is not None:
-            arguments["seed"] = inputs.seed
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "fal-ai/bytedance/seedance/v1/pro/text-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,  # Approximate mid-point progress
-                                phase="processing",
-                                message=message,
-                            )
-                        )
-
-        # Get final result
-        result = await handler.get()
-
-        # Extract video from result
-        # fal.ai returns: {"video": {"url": "...", "content_type": "video/mp4", ...}, "seed": 123}
-        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 aspect ratio and resolution
-        width, height = self._calculate_dimensions(inputs.aspect_ratio, inputs.resolution)
-
-        # Store video result
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format="mp4",
-            width=width,
-            height=height,
-            duration=float(inputs.duration),
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    def _calculate_dimensions(self, aspect_ratio: str, resolution: str) -> tuple[int, int]:
-        """Calculate video dimensions based on aspect ratio and resolution.
-
-        Args:
-            aspect_ratio: Video aspect ratio (e.g., "16:9", "21:9")
-            resolution: Video resolution (e.g., "1080p", "720p", "480p")
-
-        Returns:
-            Tuple of (width, height) in pixels
-        """
-        # Base heights for each resolution
-        resolution_heights = {
-            "1080p": 1080,
-            "720p": 720,
-            "480p": 480,
-        }
-
-        # Parse aspect ratio
-        aspect_parts = aspect_ratio.split(":")
-        aspect_width = int(aspect_parts[0])
-        aspect_height = int(aspect_parts[1])
-
-        # Get base height for resolution
-        height = resolution_heights[resolution]
-
-        # Calculate width based on aspect ratio
-        width = int((height * aspect_width) / aspect_height)
-
-        return width, height
-
-    async def estimate_cost(self, inputs: BytedanceSeedanceV1ProTextToVideoInput) -> float:
-        """Estimate cost for Bytedance Seedance 1.0 Pro generation.
-
-        Pricing information not provided in official documentation.
-        Estimated at $0.12 per video based on typical video generation costs.
-        Cost may vary based on duration and resolution settings.
-        """
-        # Base cost per video
-        base_cost = 0.12
-
-        # Adjust for longer durations (higher cost for longer videos)
-        duration_seconds = int(inputs.duration)
-        duration_multiplier = 1.0 + ((duration_seconds - 5) * 0.05)  # +5% per second above 5s
-
-        # Adjust for higher resolutions
-        resolution_multiplier = {
-            "480p": 0.8,  # Lower quality, lower cost
-            "720p": 1.0,  # Standard
-            "1080p": 1.3,  # Higher quality, higher cost
-        }[inputs.resolution]
-
-        return base_cost * duration_multiplier * resolution_multiplier

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

@@ -1,161 +0,0 @@
-"""
-fal.ai creatify/lipsync video generator.
-
-Generates realistic lip-synchronization videos from audio and video inputs
-using Creatify's lipsync model on fal.ai. Optimized for speed, quality, and
-consistency.
-
-Based on Fal AI's creatify/lipsync model.
-See: https://fal.ai/models/creatify/lipsync
-"""
-
-import os
-
-from pydantic import BaseModel, Field
-
-from ....artifacts import AudioArtifact, VideoArtifact
-from ....base import BaseGenerator, GeneratorExecutionContext, GeneratorResult
-
-
-class CreatifyLipsyncInput(BaseModel):
-    """Input schema for creatify/lipsync.
-
-    Artifact fields are automatically detected via type introspection
-    and resolved from generation IDs to artifact objects.
-    """
-
-    video: VideoArtifact = Field(description="The video to use for lipsync")
-    audio: AudioArtifact = Field(description="The audio to use for lipsync")
-    loop: bool = Field(
-        default=True,
-        description="Repeats video if shorter than audio",
-    )
-
-
-class FalCreatifyLipsyncGenerator(BaseGenerator):
-    """Generator for realistic lip-synchronization videos."""
-
-    name = "fal-creatify-lipsync"
-    description = "Fal: Creatify Lipsync - Realistic lipsync video optimized for speed and quality"
-    artifact_type = "video"
-
-    def get_input_schema(self) -> type[CreatifyLipsyncInput]:
-        """Return the input schema for this generator."""
-        return CreatifyLipsyncInput
-
-    async def generate(
-        self, inputs: CreatifyLipsyncInput, context: GeneratorExecutionContext
-    ) -> GeneratorResult:
-        """Generate lip-synced video using creatify/lipsync."""
-        # 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 FalCreatifyLipsyncGenerator. "
-                "Install with: pip install weirdfingers-boards[generators-fal]"
-            ) from e
-
-        # Upload video and audio artifacts to Fal's public storage
-        # Fal API requires publicly accessible URLs
-        from ..utils import upload_artifacts_to_fal
-
-        # Upload video and audio separately
-        video_urls = await upload_artifacts_to_fal([inputs.video], context)
-        audio_urls = await upload_artifacts_to_fal([inputs.audio], context)
-
-        # Prepare arguments for fal.ai API
-        arguments = {
-            "video_url": video_urls[0],
-            "audio_url": audio_urls[0],
-            "loop": inputs.loop,
-        }
-
-        # Submit async job
-        handler = await fal_client.submit_async(
-            "creatify/lipsync",
-            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,  # Approximate mid-point progress
-                                phase="processing",
-                                message=message,
-                            )
-                        )
-
-        # Get final result
-        result = await handler.get()
-
-        # Extract video from result
-        # fal.ai returns: {"video": {"url": "...", "content_type": "video/mp4", ...}}
-        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")
-
-        # Extract format from content_type (e.g., "video/mp4" -> "mp4")
-        # Creatify lipsync always produces MP4 videos, so default to mp4
-        content_type = video_data.get("content_type", "video/mp4")
-        if content_type.startswith("video/"):
-            video_format = content_type.split("/")[-1]
-        else:
-            # If content_type is not a video mime type (e.g., application/octet-stream),
-            # default to mp4 since creatify/lipsync only produces mp4 videos
-            video_format = "mp4"
-
-        # Store the video result
-        # Note: The API doesn't return width/height/duration/fps, so we use defaults
-        # The actual dimensions will be the same as the input video
-        artifact = await context.store_video_result(
-            storage_url=video_url,
-            format=video_format,
-            width=inputs.video.width,
-            height=inputs.video.height,
-            duration=inputs.audio.duration,
-            fps=inputs.video.fps,
-            output_index=0,
-        )
-
-        return GeneratorResult(outputs=[artifact])
-
-    async def estimate_cost(self, inputs: CreatifyLipsyncInput) -> float:
-        """Estimate cost for creatify/lipsync generation in USD.
-
-        Pricing not specified in documentation, using estimate based on
-        typical video processing costs.
-        """
-        # Base cost estimate per generation
-        return 0.05