@weirdfingers/baseboards 0.6.2 → 0.8.0

package/templates/api/src/boards/generators/implementations/kie/image/nano_banana_edit.py

@@ -0,0 +1,190 @@
+"""
+Kie.ai nano-banana image-to-image editing generator.
+
+Edit images using Kie.ai's google/nano-banana-edit model (powered by Google Gemini).
+Supports editing multiple input images with a text prompt.
+
+Based on Kie.ai's google/nano-banana-edit model.
+See: https://docs.kie.ai/market/google/nano-banana-edit
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import GeneratorExecutionContext, GeneratorResult
+from ..base import KieMarketAPIGenerator
+
+
+class NanoBananaEditInput(BaseModel):
+    """Input schema for nano-banana image editing.
+
+    Artifact fields (like image_sources) are automatically detected via type
+    introspection and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    prompt: str = Field(
+        description="The prompt for image editing",
+        max_length=5000,
+    )
+    image_sources: list[ImageArtifact] = Field(
+        description="List of input images for editing (from previous generations)",
+        min_length=1,
+        max_length=10,
+    )
+    output_format: Literal["png", "jpeg"] = Field(
+        default="png",
+        description="Output image format",
+    )
+    image_size: Literal[
+        "1:1",
+        "9:16",
+        "16:9",
+        "3:4",
+        "4:3",
+        "3:2",
+        "2:3",
+        "5:4",
+        "4:5",
+        "21:9",
+        "auto",
+    ] = Field(
+        default="1:1",
+        description="Output image aspect ratio",
+    )
+
+
+class KieNanoBananaEditGenerator(KieMarketAPIGenerator):
+    """nano-banana image editing generator using Kie.ai Market API."""
+
+    name = "kie-nano-banana-edit"
+    artifact_type = "image"
+    description = "Kie.ai: Google nano-banana edit - AI-powered image editing with Gemini"
+
+    # Market API configuration
+    model_id = "google/nano-banana-edit"
+
+    def get_input_schema(self) -> type[NanoBananaEditInput]:
+        return NanoBananaEditInput
+
+    async def generate(
+        self, inputs: NanoBananaEditInput, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Edit images using Kie.ai google/nano-banana-edit model."""
+        # Get API key using base class method
+        api_key = self._get_api_key()
+
+        # Upload image artifacts to Kie.ai's public storage
+        # Kie.ai 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 Kie.ai's temporary storage first
+        from ..utils import upload_artifacts_to_kie
+
+        image_urls = await upload_artifacts_to_kie(inputs.image_sources, context)
+
+        # Prepare request body for Market API
+        body = {
+            "model": self.model_id,
+            "input": {
+                "prompt": inputs.prompt,
+                "image_urls": image_urls,
+                "output_format": inputs.output_format,
+                "image_size": inputs.image_size,
+            },
+        }
+
+        # Submit task using base class method
+        submit_url = "https://api.kie.ai/api/v1/jobs/createTask"
+        result = await self._make_request(submit_url, "POST", api_key, json=body)
+
+        # Extract task ID with safe dictionary access
+        data = result.get("data", {})
+        task_id = data.get("taskId")
+
+        if not task_id:
+            raise ValueError(f"No taskId returned from Kie.ai API. Response: {result}")
+
+        # Store external job ID
+        await context.set_external_job_id(task_id)
+
+        # Poll for completion using base class method
+        task_data = await self._poll_for_completion(task_id, api_key, context)
+
+        # Extract outputs from resultJson
+        result_json = task_data.get("resultJson")
+        if result_json:
+            import json
+
+            result_data = json.loads(result_json)
+        else:
+            result_data = task_data.get("result")
+
+        if not result_data:
+            raise ValueError("No result data returned from Kie.ai API")
+
+        # Extract image URLs from result
+        # The response structure may vary, but typically contains image URLs
+        # Based on the API pattern, result should contain the generated images
+        images = result_data.get("images", [])
+
+        if not images:
+            # Sometimes the result might directly contain URLs in different structure
+            # Try to extract from common patterns
+            if isinstance(result_data, dict):
+                # Check for common response patterns
+                if "resultUrls" in result_data:
+                    # Market API returns resultUrls as array of strings
+                    images = [{"url": url} for url in result_data["resultUrls"]]
+                elif "image_urls" in result_data:
+                    images = [{"url": url} for url in result_data["image_urls"]]
+                elif "url" in result_data:
+                    images = [{"url": result_data["url"]}]
+                else:
+                    raise ValueError(f"No images found in result: {result_data}")
+            else:
+                raise ValueError("No images returned from Kie.ai API")
+
+        # Store each image using output_index
+        artifacts = []
+        for idx, image_data in enumerate(images):
+            if isinstance(image_data, str):
+                image_url = image_data
+                width = 1024
+                height = 1024
+            elif isinstance(image_data, dict):
+                image_url = image_data.get("url")
+                # Extract dimensions if available, otherwise use sensible defaults
+                width = image_data.get("width", 1024)
+                height = image_data.get("height", 1024)
+            else:
+                raise ValueError(f"Unexpected image data format: {type(image_data)}")
+
+            if not image_url:
+                raise ValueError(f"Image {idx} missing URL in Kie.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: NanoBananaEditInput) -> float:
+        """Estimate cost for nano-banana edit generation.
+
+        nano-banana/edit uses Google Gemini for image editing.
+        Estimated at $0.025 per image (approximately 35% cheaper than Fal's $0.039).
+
+        Note: Actual pricing should be verified at https://kie.ai/pricing
+        """
+        # Cost per image - this is an estimate and should be updated with actual pricing
+        per_image_cost = 0.025
+        num_images = len(inputs.image_sources)
+        return per_image_cost * num_images

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

@@ -0,0 +1,98 @@
+"""
+Shared utilities for Kie.ai generators.
+
+Provides helper functions for common operations across Kie generators.
+"""
+
+import asyncio
+import os
+
+import httpx
+
+from ...artifacts import AudioArtifact, DigitalArtifact, ImageArtifact, VideoArtifact
+from ...base import GeneratorExecutionContext
+
+
+async def upload_artifacts_to_kie[T: DigitalArtifact](
+    artifacts: list[ImageArtifact] | list[VideoArtifact] | list[AudioArtifact] | list[T],
+    context: GeneratorExecutionContext,
+) -> list[str]:
+    """
+    Upload artifacts to Kie.ai's temporary storage for use in API requests.
+
+    Kie.ai 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 Kie.ai's public temporary storage
+    3. Get back publicly accessible URLs
+
+    Note: Files uploaded to Kie.ai storage expire after 3 days.
+
+    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 Kie.ai storage
+
+    Raises:
+        ValueError: If KIE_API_KEY is not set
+        Any exceptions from file resolution or upload are propagated
+    """
+    api_key = os.getenv("KIE_API_KEY")
+    if not api_key:
+        raise ValueError("KIE_API_KEY environment variable is required for file uploads")
+
+    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 Kie.ai's temporary storage
+        # Using file stream upload API
+        async with httpx.AsyncClient() as client:
+            with open(file_path_str, "rb") as f:
+                files = {"file": f}
+                # uploadPath is required by Kie.ai API - specifies the storage path
+                data = {"uploadPath": "boards/temp"}
+                response = await client.post(
+                    "https://kieai.redpandaai.co/api/file-stream-upload",
+                    files=files,
+                    data=data,
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    timeout=120.0,  # 2 minute timeout for uploads
+                )
+
+            if response.status_code != 200:
+                raise ValueError(f"File upload failed: {response.status_code} {response.text}")
+
+            result = response.json()
+
+            if not result.get("success"):
+                raise ValueError(f"File upload failed: {result.get('msg')}")
+
+            # Extract the public URL from response data
+            data = result.get("data", {})
+
+            # The actual field name is 'downloadUrl' based on API response
+            file_url = data.get("downloadUrl")
+
+            if not file_url:
+                # Fallback to other possible field names
+                file_url = data.get("fileUrl") or data.get("file_url") or data.get("url")
+
+            if not file_url:
+                # If we still can't find the URL, provide detailed error message
+                raise ValueError(
+                    f"File upload succeeded but couldn't find URL in response. "
+                    f"Response data keys: {list(data.keys())}, "
+                    f"Full response: {result}"
+                )
+
+            return file_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/kie/video/__init__.py

@@ -0,0 +1,8 @@
+"""Kie.ai video generators."""
+
+from .veo3 import KieVeo3Generator, KieVeo3Input
+
+__all__ = [
+    "KieVeo3Generator",
+    "KieVeo3Input",
+]

package/templates/api/src/boards/generators/implementations/kie/video/veo3.py

@@ -0,0 +1,161 @@
+"""
+Kie.ai Veo 3.1 text-to-video and image-to-video generator.
+
+Generate high-quality videos from text prompts with optional image inputs
+using Kie.ai's Google Veo 3.1 model (Dedicated API).
+
+Based on Kie.ai's Veo 3.1 API.
+See: https://docs.kie.ai/veo3-api/generate-veo-3-video
+"""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from ....artifacts import ImageArtifact
+from ....base import GeneratorExecutionContext, GeneratorResult
+from ..base import KieDedicatedAPIGenerator
+
+
+class KieVeo3Input(BaseModel):
+    """Input schema for Kie.ai Veo 3.1 video generation.
+
+    Supports both text-to-video and image-to-video modes.
+    Artifact fields (like image_sources) are automatically detected via type
+    introspection and resolved from generation IDs to ImageArtifact objects.
+    """
+
+    prompt: str = Field(
+        description="The text prompt describing the video you want to generate",
+        max_length=5000,
+    )
+    image_sources: list[ImageArtifact] | None = Field(
+        default=None,
+        description="Optional list of 1-2 input images for image-to-video generation",
+        min_length=1,
+        max_length=2,
+    )
+    aspect_ratio: Literal["16:9", "9:16", "Auto"] = Field(
+        default="16:9",
+        description="Aspect ratio of the generated video",
+    )
+    model: Literal["veo3", "veo3_fast"] = Field(
+        default="veo3",
+        description="Model variant to use (veo3 for quality, veo3_fast for speed)",
+    )
+
+
+class KieVeo3Generator(KieDedicatedAPIGenerator):
+    """Veo 3.1 video generator using Kie.ai Dedicated API."""
+
+    name = "kie-veo3"
+    artifact_type = "video"
+    description = "Kie.ai: Google Veo 3.1 - High-quality AI video generation"
+
+    # Dedicated API configuration
+    model_id = "veo3"
+
+    def get_input_schema(self) -> type[KieVeo3Input]:
+        return KieVeo3Input
+
+    def _get_status_url(self, task_id: str) -> str:
+        """Get the Veo3-specific status check URL."""
+        return f"https://api.kie.ai/api/v1/veo/record-info?taskId={task_id}"
+
+    async def generate(
+        self, inputs: KieVeo3Input, context: GeneratorExecutionContext
+    ) -> GeneratorResult:
+        """Generate video using Kie.ai Veo 3.1 model."""
+        # Get API key using base class method
+        api_key = self._get_api_key()
+
+        # Prepare request body for Dedicated API
+        body: dict[str, Any] = {
+            "prompt": inputs.prompt,
+            "aspectRatio": inputs.aspect_ratio,
+            "model": inputs.model,
+        }
+
+        # Upload image artifacts if provided (for image-to-video mode)
+        if inputs.image_sources:
+            from ..utils import upload_artifacts_to_kie
+
+            image_urls = await upload_artifacts_to_kie(inputs.image_sources, context)
+            body["imageUrls"] = image_urls
+
+        # Submit task to Dedicated API endpoint using base class method
+        submit_url = "https://api.kie.ai/api/v1/veo/generate"
+        result = await self._make_request(submit_url, "POST", api_key, json=body)
+
+        # Extract task ID from Dedicated API response
+        # Try direct taskId first, then nested under 'data'
+        task_id = result.get("taskId")
+        if not task_id:
+            data = result.get("data", {})
+            task_id = data.get("taskId")
+
+        if not task_id:
+            raise ValueError(f"No taskId returned from Kie.ai API. Response: {result}")
+
+        # Store external job ID
+        await context.set_external_job_id(task_id)
+
+        # Poll for completion using base class method
+        result_data = await self._poll_for_completion(task_id, api_key, context)
+
+        # Extract video URLs from response.resultUrls field
+        # Dedicated API nests the results inside a 'response' object
+        response_data = result_data.get("response")
+        if not response_data:
+            raise ValueError(f"No response field in result. Response: {result_data}")
+
+        result_urls = response_data.get("resultUrls")
+        if not result_urls or not isinstance(result_urls, list):
+            raise ValueError(f"No resultUrls in response. Response: {result_data}")
+
+        # Determine video dimensions based on aspect ratio
+        # Default to 1080p quality
+        if inputs.aspect_ratio == "16:9":
+            width, height = 1920, 1080
+        elif inputs.aspect_ratio == "9:16":
+            width, height = 1080, 1920
+        else:  # Auto
+            # Default to 16:9 for Auto
+            width, height = 1920, 1080
+
+        # Veo 3 generates ~8 second videos by default
+        duration = 8.0
+
+        # Store each video using output_index
+        artifacts = []
+        for idx, video_url in enumerate(result_urls):
+            if not video_url:
+                raise ValueError(f"Video {idx} missing URL in Kie.ai response")
+
+            artifact = await context.store_video_result(
+                storage_url=video_url,
+                format="mp4",
+                width=width,
+                height=height,
+                duration=duration,
+                output_index=idx,
+            )
+            artifacts.append(artifact)
+
+        return GeneratorResult(outputs=artifacts)
+
+    async def estimate_cost(self, inputs: KieVeo3Input) -> float:
+        """Estimate cost for Veo 3.1 video generation.
+
+        Veo 3.1 pricing is estimated based on typical video generation costs.
+        Actual pricing should be verified at https://kie.ai/pricing
+
+        Base cost estimates:
+        - veo3: $0.08 per video (standard quality)
+        - veo3_fast: $0.04 per video (faster generation)
+        """
+        # Cost varies by model
+        if inputs.model == "veo3_fast":
+            return 0.04
+        else:  # veo3
+            return 0.08

package/templates/api/src/boards/graphql/resolvers/upload.py

@@ -114,7 +114,7 @@ def _is_safe_url(url: str) -> tuple[bool, str | None]:
         if parsed.scheme not in ("http", "https"):
             return (
                 False,
-                f"URL scheme '{parsed.scheme}' not allowed. " "Only http and https are supported.",
+                f"URL scheme '{parsed.scheme}' not allowed. Only http and https are supported.",
             )
 
         hostname = parsed.hostname

package/templates/web/package.json

@@ -10,16 +10,19 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@radix-ui/react-alert-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@radix-ui/react-navigation-menu": "^1.2.14",
     "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-toast": "^1.2.15",
     "@tailwindcss/postcss": "^4.1.13",
-    "@weirdfingers/boards": "^0.6.2",
+    "@weirdfingers/boards": "^0.8.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.0.0",
     "graphql": "^16.11.0",
     "lucide-react": "^0.544.0",
     "next": "14.2.5",
+    "next-themes": "^0.4.6",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "tailwind-merge": "^3.3.1"