Initial StackNet Demo for Hugging Face Spaces

- Text to Music generation
- Music to Music (diffusion from reference)
- Stem extraction
- Text to Image
- Image to Image editing
- Text to Video
- Image to Video animation

.env.example

@@ -0,0 +1,3 @@
+# STACKNET Configuration
+STACKNET_NETWORK_URL=https://geoffnet.magma-rpc.com
+STACKNET_SERVICE_KEY=gn_3a2f41ba3e33428f9dcedf54280e9ad6

.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+venv/
+.venv/
+*.egg-info/
+dist/
+build/
+.DS_Store

README.md

@@ -0,0 +1,33 @@
+---
+title: StackNet 1:1 Preview Playground
+emoji: 🎵
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+sdk_version: 5.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# StackNet 1:1 Preview Playground
+
+Explore AI-powered media generation with StackNet:
+
+- **Text to Music** - Generate original music from descriptions
+- **Music to Music** - Create from reference audio (diffusion)
+- **Extract Stems** - Separate audio into vocals, drums, bass, other
+- **Text to Image** - Generate images from descriptions
+- **Image to Image** - Transform and edit images
+- **Text to Video** - Generate videos from descriptions
+- **Image to Video** - Animate static images
+
+## Usage
+
+1. Enter your StackNet API key in the Settings section
+2. Select a tab for the type of content you want to create
+3. Enter your prompt and click generate
+
+## API Key
+
+Get your StackNet API key from [stacknet.ai](https://stacknet.ai)

app.py

@@ -0,0 +1,157 @@
+"""
+StackNet Demo
+
+
+A Gradio-based demo showcasing StackNet's capabilities:
+- Text-to-Music
+- Music-to-Music (Cover Songs, Stem Extraction)
+- Text-to-Image
+- Image-to-Image
+- Text-to-Video
+- Image-to-Video
+
+"""
+
+import gradio as gr
+
+from src.ui.tabs import create_all_tabs
+from src.ui.handlers import Handlers
+
+
+def create_demo() -> gr.Blocks:
+    """Create the complete Gradio demo application."""
+
+    with gr.Blocks(
+        title="StackNet Demo",
+    ) as demo:
+
+        gr.Markdown("""
+        # StackNet Demo 1:1 Preview
+
+        """)
+
+        with gr.Accordion("Settings", open=False):
+            api_key = gr.Textbox(
+                label="StackNet Key",
+                placeholder="Enter your key (e.g., sn_xxxx...)",
+                type="password",
+                value=""
+            )
+
+        with gr.Tabs():
+            tabs = create_all_tabs()
+
+        # Wire up event handlers (all use api_name=None to hide from API)
+
+        # Text to Music
+        ttm = tabs["text_to_music"]
+        ttm["generate_btn"].click(
+            fn=Handlers.generate_music,
+            inputs=[
+                ttm["prompt"],
+                ttm["tags"],
+                ttm["instrumental"],
+                ttm["lyrics"],
+                ttm["title"],
+                api_key
+            ],
+            outputs=[ttm["output_audio"], ttm["status"]],
+            api_name=None
+        )
+
+        # Music to Music - Cover
+        mtm = tabs["music_to_music"]
+        mtm["cover_btn"].click(
+            fn=Handlers.create_cover,
+            inputs=[
+                mtm["cover_audio_input"],
+                mtm["cover_style_prompt"],
+                mtm["cover_tags"],
+                mtm["cover_title"],
+                api_key
+            ],
+            outputs=[mtm["cover_output"], mtm["cover_status"]],
+            api_name=None
+        )
+
+        # Music to Music - Stems
+        mtm["stems_btn"].click(
+            fn=Handlers.extract_stems,
+            inputs=[mtm["stems_audio_input"], api_key],
+            outputs=[
+                mtm["vocals_output"],
+                mtm["drums_output"],
+                mtm["bass_output"],
+                mtm["other_output"],
+                mtm["stems_status"]
+            ],
+            api_name=None
+        )
+
+        # Text to Image
+        tti = tabs["text_to_image"]
+        tti["generate_btn"].click(
+            fn=Handlers.generate_image,
+            inputs=[
+                tti["prompt"],
+                tti["style"],
+                tti["aspect_ratio"],
+                api_key
+            ],
+            outputs=[tti["output_image"], tti["status"]],
+            api_name=None
+        )
+
+        # Image to Image
+        iti = tabs["image_to_image"]
+        iti["edit_btn"].click(
+            fn=Handlers.edit_image,
+            inputs=[
+                iti["input_image"],
+                iti["edit_prompt"],
+                iti["strength"],
+                api_key
+            ],
+            outputs=[iti["output_image"], iti["status"]],
+            api_name=None
+        )
+
+        # Text to Video
+        ttv = tabs["text_to_video"]
+        ttv["generate_btn"].click(
+            fn=Handlers.generate_video,
+            inputs=[
+                ttv["prompt"],
+                ttv["duration"],
+                ttv["style"],
+                api_key
+            ],
+            outputs=[ttv["output_video"], ttv["status"]],
+            api_name=None
+        )
+
+        # Image to Video
+        itv = tabs["image_to_video"]
+        itv["animate_btn"].click(
+            fn=Handlers.animate_image,
+            inputs=[
+                itv["input_image"],
+                itv["motion_prompt"],
+                itv["duration"],
+                api_key
+            ],
+            outputs=[itv["output_video"], itv["status"]],
+            api_name=None
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        theme=gr.themes.Soft(),
+    )

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+httpx>=0.25.0
+python-dotenv>=1.0.0

src/__init__.py

@@ -0,0 +1 @@
+# StackNet Demo - Source Package

src/api/__init__.py

@@ -0,0 +1,4 @@
+# API Client Package
+from .client import StackNetClient
+
+__all__ = ["StackNetClient"]

src/api/client.py

@@ -0,0 +1,257 @@
+"""
+StackNet API Client
+
+Handles all communication with the StackNettask network.
+SSE parsing and progress tracking are handled internally.
+"""
+
+import json
+import tempfile
+import os
+from typing import AsyncGenerator, Optional, Any, Callable
+from dataclasses import dataclass
+from enum import Enum
+
+import httpx
+
+from ..config import config
+
+
+class MediaAction(str, Enum):
+    """Supported media orchestration actions."""
+    GENERATE_MUSIC = "generate_music"
+    CREATE_COVER = "create_cover"
+    EXTRACT_STEMS = "extract_stems"
+    ANALYZE_VISUAL = "analyze_visual"
+    DESCRIBE_VIDEO = "describe_video"
+    CREATE_COMPOSITE = "create_composite"
+
+
+@dataclass
+class TaskProgress:
+    """Progress update from a running task."""
+    progress: float  # 0.0 to 1.0
+    status: str
+    message: str
+
+
+@dataclass
+class TaskResult:
+    """Final result from a completed task."""
+    success: bool
+    data: dict
+    error: Optional[str] = None
+
+
+class StackNetClient:
+    """
+    Client for StackNet task network API.
+
+    All SSE parsing and polling is handled internally.
+    Consumers receive clean progress updates and final results.
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        timeout: float = 300.0
+    ):
+        self.base_url = base_url or config.stacknet_url
+        self.api_key = api_key or config.stacknet_api_key
+        self.timeout = timeout
+        self._temp_dir = tempfile.mkdtemp(prefix="stacknet_")
+
+    async def submit_media_task(
+        self,
+        action: MediaAction,
+        prompt: Optional[str] = None,
+        media_url: Optional[str] = None,
+        audio_url: Optional[str] = None,
+        video_url: Optional[str] = None,
+        options: Optional[dict] = None,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> TaskResult:
+        """
+        Submit a media orchestration task and wait for completion.
+
+        Args:
+            action: The media action to perform
+            prompt: Text prompt for generation
+            media_url: URL for image input
+            audio_url: URL for audio input
+            video_url: URL for video input
+            options: Additional options (tags, title, etc.)
+            on_progress: Callback for progress updates (progress: 0-1, message: str)
+
+        Returns:
+            TaskResult with success status and output data
+        """
+        payload = {
+            "type": config.TASK_TYPE_MEDIA,
+            "action": action.value,
+            "stream": True,
+        }
+
+        if prompt:
+            payload["prompt"] = prompt
+        if media_url:
+            payload["mediaUrl"] = media_url
+        if audio_url:
+            payload["audioUrl"] = audio_url
+        if video_url:
+            payload["videoUrl"] = video_url
+        if options:
+            payload["options"] = options
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            auth_header = self.api_key if self.api_key.startswith("Bearer ") else f"Bearer {self.api_key}"
+            headers["Authorization"] = auth_header
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            try:
+                async with client.stream(
+                    "POST",
+                    f"{self.base_url}/tasks",
+                    json=payload,
+                    headers=headers
+                ) as response:
+                    if response.status_code != 200:
+                        error_text = await response.aread()
+                        return TaskResult(
+                            success=False,
+                            data={},
+                            error=f"API request failed ({response.status_code}): {error_text.decode()[:200]}"
+                        )
+
+                    return await self._process_sse_stream(response, on_progress)
+
+            except httpx.TimeoutException:
+                return TaskResult(
+                    success=False,
+                    data={},
+                    error="Request timed out. The operation took too long."
+                )
+            except httpx.RequestError as e:
+                return TaskResult(
+                    success=False,
+                    data={},
+                    error=f"Network error: {str(e)}"
+                )
+
+    async def _process_sse_stream(
+        self,
+        response: httpx.Response,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> TaskResult:
+        """Process SSE stream and extract final result."""
+        buffer = ""
+        final_result: Optional[dict] = None
+        error_message: Optional[str] = None
+
+        async for chunk in response.aiter_text():
+            buffer += chunk
+            lines = buffer.split("\n")
+            buffer = lines.pop()  # Keep incomplete line
+
+            for line in lines:
+                if not line.startswith("data: "):
+                    continue
+
+                raw_data = line[6:].strip()
+
+                # Skip markers
+                if raw_data == "[DONE]" or not raw_data:
+                    continue
+
+                try:
+                    event = json.loads(raw_data)
+                    event_type = event.get("type", "")
+                    event_data = event.get("data", event)
+
+                    if event_type == "progress":
+                        if on_progress:
+                            progress = self._calculate_progress(event_data)
+                            message = event_data.get("message", "Processing...")
+                            on_progress(progress, message)
+
+                    elif event_type == "result":
+                        final_result = event_data.get("output", event_data)
+
+                    elif event_type == "error":
+                        error_message = event_data.get("message", "Unknown error occurred")
+
+                    elif event_type == "complete":
+                        # Task completed successfully
+                        pass
+
+                except json.JSONDecodeError:
+                    continue
+
+        # Process any remaining buffer
+        if buffer.strip() and buffer.startswith("data: "):
+            raw_data = buffer[6:].strip()
+            if raw_data and raw_data != "[DONE]":
+                try:
+                    event = json.loads(raw_data)
+                    if event.get("type") == "result":
+                        final_result = event.get("data", {}).get("output", event.get("data", {}))
+                except json.JSONDecodeError:
+                    pass
+
+        if error_message:
+            return TaskResult(success=False, data={}, error=error_message)
+
+        if final_result:
+            return TaskResult(success=True, data=final_result)
+
+        return TaskResult(
+            success=False,
+            data={},
+            error="No result received from the API"
+        )
+
+    def _calculate_progress(self, data: dict) -> float:
+        """Calculate normalized progress (0.0 to 1.0)."""
+        if not data:
+            return 0.5
+
+        status = data.get("status", "")
+
+        if status == "completed":
+            return 1.0
+        if status == "polling":
+            attempt = data.get("attempt", 1)
+            max_attempts = data.get("maxAttempts", 30)
+            return 0.2 + (attempt / max_attempts) * 0.6
+        if status == "processing":
+            return 0.5
+        if status == "submitted":
+            return 0.1
+
+        return 0.5
+
+    async def download_file(self, url: str, filename: Optional[str] = None) -> str:
+        """Download a file to the temp directory and return local path."""
+        if not filename:
+            filename = url.split("/")[-1].split("?")[0]
+            if not filename:
+                filename = "download"
+
+        local_path = os.path.join(self._temp_dir, filename)
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+
+            with open(local_path, "wb") as f:
+                f.write(response.content)
+
+        return local_path
+
+    def cleanup(self):
+        """Clean up temporary files."""
+        import shutil
+        if os.path.exists(self._temp_dir):
+            shutil.rmtree(self._temp_dir, ignore_errors=True)

src/config.py

@@ -0,0 +1,42 @@
+"""
+Configuration management for StackNet Demo.
+
+Loads settings from environment variables with sensible defaults.
+"""
+
+import os
+from dataclasses import dataclass
+from dotenv import load_dotenv
+
+# Load .env file if present
+load_dotenv()
+
+
+@dataclass
+class Config:
+    """Application configuration."""
+
+    # StackNet API
+    stacknet_url: str = os.getenv("STACKNET_NETWORK_URL", "https://geoffnet.magma-rpc.com")
+    stacknet_api_key: str = os.getenv("STACKNET_SERVICE_KEY", "")
+
+    # Endpoints
+    @property
+    def tasks_endpoint(self) -> str:
+        return f"{self.stacknet_url}/tasks"
+
+    @property
+    def chat_endpoint(self) -> str:
+        return f"{self.stacknet_url}/v1/chat/completions"
+
+    # Timeouts (seconds)
+    request_timeout: float = 300.0  # 5 minutes for long operations
+
+    # Task types
+    TASK_TYPE_MEDIA = "media-orchestration"
+    TASK_TYPE_MCP = "mcp-tool"
+    TASK_TYPE_AI_PROMPT = "ai-prompt"
+
+
+# Global config instance
+config = Config()

src/services/__init__.py

@@ -0,0 +1,6 @@
+# Services Package
+from .music import MusicService
+from .image import ImageService
+from .video import VideoService
+
+__all__ = ["MusicService", "ImageService", "VideoService"]

src/services/image.py

@@ -0,0 +1,171 @@
+"""
+Image Service
+
+High-level service for image generation and editing.
+Abstracts all API complexity from the UI layer.
+"""
+
+from typing import Callable, Optional, List
+from dataclasses import dataclass
+
+from ..api.client import StackNetClient, MediaAction
+
+
+@dataclass
+class GeneratedImage:
+    """Generated image result."""
+    image_url: str
+    image_path: Optional[str] = None
+    prompt: Optional[str] = None
+    width: Optional[int] = None
+    height: Optional[int] = None
+
+
+class ImageService:
+    """
+    Service for image generation and editing.
+
+    Provides clean interfaces for:
+    - Text-to-image generation
+    - Image-to-image editing/transformation
+    """
+
+    def __init__(self, client: Optional[StackNetClient] = None):
+        self.client = client or StackNetClient()
+
+    async def generate_image(
+        self,
+        prompt: str,
+        style: Optional[str] = None,
+        aspect_ratio: Optional[str] = None,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[GeneratedImage]:
+        """
+        Generate image from a text prompt.
+
+        Args:
+            prompt: Description of desired image
+            style: Style preset (Photorealistic, Digital Art, etc.)
+            aspect_ratio: Aspect ratio (1:1, 16:9, 9:16, etc.)
+            on_progress: Callback for progress updates
+
+        Returns:
+            List of generated images
+        """
+        full_prompt = prompt
+        if style and style != "Photorealistic":
+            full_prompt = f"{prompt}, {style.lower()} style"
+
+        options = {}
+        if aspect_ratio:
+            options["aspect_ratio"] = aspect_ratio
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.ANALYZE_VISUAL,
+            prompt=full_prompt,
+            options=options if options else None,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Image generation failed")
+
+        return self._parse_image_result(result.data, prompt)
+
+    async def edit_image(
+        self,
+        image_url: str,
+        edit_prompt: str,
+        strength: float = 0.5,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[GeneratedImage]:
+        """
+        Edit/transform an existing image.
+
+        Args:
+            image_url: URL to source image
+            edit_prompt: Edit instructions
+            strength: Edit strength (0.1 to 1.0)
+            on_progress: Progress callback
+
+        Returns:
+            List of edited images
+        """
+        options = {
+            "strength": strength,
+            "edit_mode": True
+        }
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.ANALYZE_VISUAL,
+            media_url=image_url,
+            prompt=edit_prompt,
+            options=options,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Image editing failed")
+
+        return self._parse_image_result(result.data, edit_prompt)
+
+    def _parse_image_result(self, data: dict, prompt: str) -> List[GeneratedImage]:
+        """Parse API response into GeneratedImage objects."""
+        images = []
+
+        # Handle various response formats
+        raw_images = data.get("images", [])
+
+        if not raw_images:
+            # Check for single image URL
+            image_url = (
+                data.get("image_url") or
+                data.get("imageUrl") or
+                data.get("url") or
+                data.get("content")
+            )
+            if image_url:
+                raw_images = [{"url": image_url}]
+
+        for img_data in raw_images:
+            if isinstance(img_data, str):
+                # Raw URL string
+                image_url = img_data
+            else:
+                image_url = (
+                    img_data.get("url") or
+                    img_data.get("image_url") or
+                    img_data.get("imageUrl")
+                )
+
+            if image_url:
+                images.append(GeneratedImage(
+                    image_url=image_url,
+                    prompt=prompt,
+                    width=img_data.get("width") if isinstance(img_data, dict) else None,
+                    height=img_data.get("height") if isinstance(img_data, dict) else None
+                ))
+
+        return images
+
+    async def download_image(self, image: GeneratedImage) -> str:
+        """Download an image to local file."""
+        if image.image_path:
+            return image.image_path
+
+        # Determine extension from URL
+        url = image.image_url
+        if ".png" in url:
+            ext = ".png"
+        elif ".jpg" in url or ".jpeg" in url:
+            ext = ".jpg"
+        else:
+            ext = ".png"
+
+        filename = f"image_{hash(url) % 10000}{ext}"
+        image.image_path = await self.client.download_file(url, filename)
+        return image.image_path
+
+    def cleanup(self):
+        """Clean up temporary files."""
+        self.client.cleanup()

src/services/music.py

@@ -0,0 +1,220 @@
+"""
+Music Service
+
+High-level service for music generation operations.
+Abstracts all API complexity from the UI layer.
+"""
+
+from typing import Callable, Optional, List
+from dataclasses import dataclass, field
+
+from ..api.client import StackNetClient, MediaAction
+
+
+@dataclass
+class MusicClip:
+    """Generated music clip."""
+    title: str
+    audio_url: str
+    audio_path: Optional[str] = None
+    duration: Optional[str] = None
+    image_url: Optional[str] = None
+    video_url: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+
+
+@dataclass
+class StemResult:
+    """Extracted audio stems."""
+    vocals_path: Optional[str] = None
+    drums_path: Optional[str] = None
+    bass_path: Optional[str] = None
+    other_path: Optional[str] = None
+
+
+class MusicService:
+    """
+    Service for music generation and manipulation.
+
+    Provides clean interfaces for:
+    - Text-to-music generation
+    - Cover song creation
+    - Stem extraction
+    """
+
+    def __init__(self, client: Optional[StackNetClient] = None):
+        self.client = client or StackNetClient()
+
+    async def generate_music(
+        self,
+        prompt: str,
+        title: Optional[str] = None,
+        tags: Optional[str] = None,
+        lyrics: Optional[str] = None,
+        instrumental: bool = False,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[MusicClip]:
+        """
+        Generate original music from a text prompt.
+
+        Args:
+            prompt: Description of desired music
+            title: Optional song title
+            tags: Optional genre/style tags (comma-separated)
+            lyrics: Optional lyrics (ignored if instrumental=True)
+            instrumental: Generate instrumental only
+            on_progress: Callback for progress updates
+
+        Returns:
+            List of generated MusicClip objects
+        """
+        options = {}
+        if tags:
+            options["tags"] = tags
+        if title:
+            options["title"] = title
+        if instrumental:
+            options["make_instrumental"] = True
+        if lyrics and not instrumental:
+            options["lyrics"] = lyrics
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.GENERATE_MUSIC,
+            prompt=prompt,
+            options=options if options else None,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Music generation failed")
+
+        return self._parse_music_result(result.data)
+
+    async def create_cover(
+        self,
+        audio_url: str,
+        style_prompt: str,
+        title: Optional[str] = None,
+        tags: Optional[str] = None,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[MusicClip]:
+        """
+        Create a cover version of audio.
+
+        Args:
+            audio_url: URL to source audio
+            style_prompt: Style/voice direction for the cover
+            title: Optional title for the cover
+            tags: Optional genre/style tags
+            on_progress: Progress callback
+
+        Returns:
+            List of generated cover clips
+        """
+        options = {}
+        if tags:
+            options["tags"] = tags
+        if title:
+            options["title"] = title
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.CREATE_COVER,
+            audio_url=audio_url,
+            prompt=style_prompt,
+            options=options if options else None,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Cover creation failed")
+
+        return self._parse_music_result(result.data)
+
+    async def extract_stems(
+        self,
+        audio_url: str,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> StemResult:
+        """
+        Extract stems (vocals, drums, bass, other) from audio.
+
+        Args:
+            audio_url: URL to source audio
+            on_progress: Progress callback
+
+        Returns:
+            StemResult with paths to each stem
+        """
+        result = await self.client.submit_media_task(
+            action=MediaAction.EXTRACT_STEMS,
+            audio_url=audio_url,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Stem extraction failed")
+
+        stems_data = result.data.get("stems", result.data)
+
+        stem_result = StemResult()
+
+        # Download each stem if URL provided
+        if stems_data.get("vocals"):
+            stem_result.vocals_path = await self.client.download_file(
+                stems_data["vocals"], "vocals.mp3"
+            )
+        if stems_data.get("drums"):
+            stem_result.drums_path = await self.client.download_file(
+                stems_data["drums"], "drums.mp3"
+            )
+        if stems_data.get("bass"):
+            stem_result.bass_path = await self.client.download_file(
+                stems_data["bass"], "bass.mp3"
+            )
+        if stems_data.get("other"):
+            stem_result.other_path = await self.client.download_file(
+                stems_data["other"], "other.mp3"
+            )
+
+        return stem_result
+
+    def _parse_music_result(self, data: dict) -> List[MusicClip]:
+        """Parse API response into MusicClip objects."""
+        clips = []
+
+        # Handle various response formats
+        raw_clips = data.get("clips", [])
+
+        # If no clips array, treat the data itself as a single clip
+        if not raw_clips:
+            if data.get("audio_url") or data.get("audioUrl"):
+                raw_clips = [data]
+            elif data.get("url"):
+                raw_clips = [{"audio_url": data["url"], "title": data.get("title", "Generated")}]
+
+        for clip_data in raw_clips:
+            audio_url = clip_data.get("audio_url") or clip_data.get("audioUrl") or clip_data.get("url")
+            if audio_url:
+                clips.append(MusicClip(
+                    title=clip_data.get("title", "Generated Music"),
+                    audio_url=audio_url,
+                    duration=clip_data.get("duration"),
+                    image_url=clip_data.get("image_url") or clip_data.get("imageUrl"),
+                    video_url=clip_data.get("video_url") or clip_data.get("videoUrl"),
+                    tags=clip_data.get("tags", [])
+                ))
+
+        return clips
+
+    async def download_clip(self, clip: MusicClip) -> str:
+        """Download a clip's audio to local file."""
+        if clip.audio_path:
+            return clip.audio_path
+
+        filename = f"{clip.title.replace(' ', '_')[:30]}.mp3"
+        clip.audio_path = await self.client.download_file(clip.audio_url, filename)
+        return clip.audio_path
+
+    def cleanup(self):
+        """Clean up temporary files."""
+        self.client.cleanup()

src/services/video.py

@@ -0,0 +1,170 @@
+"""
+Video Service
+
+High-level service for video generation.
+Abstracts all API complexity from the UI layer.
+"""
+
+from typing import Callable, Optional, List
+from dataclasses import dataclass
+
+from ..api.client import StackNetClient, MediaAction
+
+
+@dataclass
+class GeneratedVideo:
+    """Generated video result."""
+    video_url: str
+    video_path: Optional[str] = None
+    thumbnail_url: Optional[str] = None
+    duration: Optional[float] = None
+    prompt: Optional[str] = None
+
+
+class VideoService:
+    """
+    Service for video generation.
+
+    Provides clean interfaces for:
+    - Text-to-video generation
+    - Image-to-video animation
+    """
+
+    def __init__(self, client: Optional[StackNetClient] = None):
+        self.client = client or StackNetClient()
+
+    async def generate_video(
+        self,
+        prompt: str,
+        duration: int = 10,
+        style: Optional[str] = None,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[GeneratedVideo]:
+        """
+        Generate video from a text prompt.
+
+        Args:
+            prompt: Description of desired video
+            duration: Target duration in seconds
+            style: Style preset (Cinematic, Animation, etc.)
+            on_progress: Callback for progress updates
+
+        Returns:
+            List of generated videos
+        """
+        full_prompt = prompt
+        if style and style != "Cinematic":
+            full_prompt = f"{prompt}, {style.lower()} style"
+
+        options = {
+            "duration": duration
+        }
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.DESCRIBE_VIDEO,
+            prompt=full_prompt,
+            options=options,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Video generation failed")
+
+        return self._parse_video_result(result.data, prompt)
+
+    async def animate_image(
+        self,
+        image_url: str,
+        motion_prompt: str,
+        duration: int = 5,
+        on_progress: Optional[Callable[[float, str], None]] = None
+    ) -> List[GeneratedVideo]:
+        """
+        Animate a static image into video.
+
+        Args:
+            image_url: URL to source image
+            motion_prompt: Description of desired motion
+            duration: Target duration in seconds
+            on_progress: Progress callback
+
+        Returns:
+            List of animated videos
+        """
+        options = {
+            "duration": duration,
+            "animate_mode": True
+        }
+
+        result = await self.client.submit_media_task(
+            action=MediaAction.DESCRIBE_VIDEO,
+            media_url=image_url,
+            prompt=motion_prompt,
+            options=options,
+            on_progress=on_progress
+        )
+
+        if not result.success:
+            raise Exception(result.error or "Image animation failed")
+
+        return self._parse_video_result(result.data, motion_prompt)
+
+    def _parse_video_result(self, data: dict, prompt: str) -> List[GeneratedVideo]:
+        """Parse API response into GeneratedVideo objects."""
+        videos = []
+
+        # Handle various response formats
+        raw_videos = data.get("videos", [])
+
+        if not raw_videos:
+            # Check for single video URL
+            video_url = (
+                data.get("video_url") or
+                data.get("videoUrl") or
+                data.get("url") or
+                data.get("content")
+            )
+            if video_url:
+                raw_videos = [{"url": video_url}]
+
+        for vid_data in raw_videos:
+            if isinstance(vid_data, str):
+                video_url = vid_data
+            else:
+                video_url = (
+                    vid_data.get("url") or
+                    vid_data.get("video_url") or
+                    vid_data.get("videoUrl")
+                )
+
+            if video_url:
+                videos.append(GeneratedVideo(
+                    video_url=video_url,
+                    thumbnail_url=vid_data.get("thumbnail") if isinstance(vid_data, dict) else None,
+                    duration=vid_data.get("duration") if isinstance(vid_data, dict) else None,
+                    prompt=prompt
+                ))
+
+        return videos
+
+    async def download_video(self, video: GeneratedVideo) -> str:
+        """Download a video to local file."""
+        if video.video_path:
+            return video.video_path
+
+        # Determine extension from URL
+        url = video.video_url
+        if ".webm" in url:
+            ext = ".webm"
+        elif ".mov" in url:
+            ext = ".mov"
+        else:
+            ext = ".mp4"
+
+        filename = f"video_{hash(url) % 10000}{ext}"
+        video.video_path = await self.client.download_file(url, filename)
+        return video.video_path
+
+    def cleanup(self):
+        """Clean up temporary files."""
+        self.client.cleanup()

src/ui/__init__.py

@@ -0,0 +1,5 @@
+# UI Package
+from .tabs import create_all_tabs
+from .handlers import Handlers
+
+__all__ = ["create_all_tabs", "Handlers"]

src/ui/handlers.py

@@ -0,0 +1,464 @@
+"""
+Event Handlers
+
+Handlers for all Gradio UI events.
+Connects UI to services with progress tracking and error handling.
+"""
+
+import asyncio
+from typing import Optional, Tuple
+import gradio as gr
+
+from ..services.music import MusicService
+from ..services.image import ImageService
+from ..services.video import VideoService
+from ..api.client import StackNetClient
+
+
+def format_error(error: Exception) -> str:
+    """Format exception as user-friendly message."""
+    msg = str(error)
+
+    # Translate common errors
+    if "timeout" in msg.lower():
+        return "The operation timed out. Please try again with a simpler prompt."
+    if "network" in msg.lower() or "connection" in msg.lower():
+        return "Network error. Please check your connection and try again."
+    if "rate limit" in msg.lower() or "429" in msg.lower():
+        return "Too many requests. Please wait a moment and try again."
+
+    return f"Error: {msg}"
+
+
+class Handlers:
+    """
+    Collection of event handlers for the Gradio UI.
+
+    All handlers hide API complexity and provide clean progress feedback.
+    """
+
+    @staticmethod
+    def generate_music(
+        prompt: str,
+        tags: str,
+        instrumental: bool,
+        lyrics: str,
+        title: str,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle text-to-music generation.
+
+        Returns:
+            Tuple of (audio_path, status_message)
+        """
+        if not prompt.strip():
+            return None, "Please enter a description for your music."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = MusicService(client=client)
+
+        try:
+            progress(0, desc="Starting music generation...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            # Run async in event loop
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                clips = loop.run_until_complete(
+                    service.generate_music(
+                        prompt=prompt,
+                        title=title if title.strip() else None,
+                        tags=tags if tags.strip() else None,
+                        lyrics=lyrics if lyrics.strip() and not instrumental else None,
+                        instrumental=instrumental,
+                        on_progress=on_progress
+                    )
+                )
+
+                if clips:
+                    # Download first clip
+                    audio_path = loop.run_until_complete(
+                        service.download_clip(clips[0])
+                    )
+                    return audio_path, "Music generation complete!"
+                else:
+                    return None, "No music was generated. Please try a different prompt."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def create_cover(
+        audio_file: str,
+        style_prompt: str,
+        tags: str,
+        title: str,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle cover song creation.
+
+        Returns:
+            Tuple of (audio_path, status_message)
+        """
+        if not audio_file:
+            return None, "Please upload an audio file."
+        if not style_prompt.strip():
+            return None, "Please describe the style for your cover."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = MusicService(client=client)
+
+        try:
+            progress(0, desc="Processing audio file...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                # For file upload, we need to use the file path as URL
+                # In production, you'd upload to a storage service first
+                audio_url = f"file://{audio_file}"
+
+                clips = loop.run_until_complete(
+                    service.create_cover(
+                        audio_url=audio_url,
+                        style_prompt=style_prompt,
+                        title=title if title.strip() else None,
+                        tags=tags if tags.strip() else None,
+                        on_progress=on_progress
+                    )
+                )
+
+                if clips:
+                    audio_path = loop.run_until_complete(
+                        service.download_clip(clips[0])
+                    )
+                    return audio_path, "Cover created successfully!"
+                else:
+                    return None, "No cover was generated. Please try again."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def extract_stems(
+        audio_file: str,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str], str]:
+        """
+        Handle stem extraction.
+
+        Returns:
+            Tuple of (vocals_path, drums_path, bass_path, other_path, status_message)
+        """
+        if not audio_file:
+            return None, None, None, None, "Please upload an audio file."
+        if not api_key.strip():
+            return None, None, None, None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = MusicService(client=client)
+
+        try:
+            progress(0, desc="Analyzing audio...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                audio_url = f"file://{audio_file}"
+
+                stems = loop.run_until_complete(
+                    service.extract_stems(
+                        audio_url=audio_url,
+                        on_progress=on_progress
+                    )
+                )
+
+                return (
+                    stems.vocals_path,
+                    stems.drums_path,
+                    stems.bass_path,
+                    stems.other_path,
+                    "Stems extracted successfully!"
+                )
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, None, None, None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def generate_image(
+        prompt: str,
+        style: str,
+        aspect_ratio: str,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle text-to-image generation.
+
+        Returns:
+            Tuple of (image_path, status_message)
+        """
+        if not prompt.strip():
+            return None, "Please enter a description for your image."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = ImageService(client=client)
+
+        try:
+            progress(0, desc="Generating image...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                images = loop.run_until_complete(
+                    service.generate_image(
+                        prompt=prompt,
+                        style=style,
+                        aspect_ratio=aspect_ratio,
+                        on_progress=on_progress
+                    )
+                )
+
+                if images:
+                    image_path = loop.run_until_complete(
+                        service.download_image(images[0])
+                    )
+                    return image_path, "Image generated successfully!"
+                else:
+                    return None, "No image was generated. Please try a different prompt."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def edit_image(
+        input_image: str,
+        edit_prompt: str,
+        strength: float,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle image-to-image editing.
+
+        Returns:
+            Tuple of (image_path, status_message)
+        """
+        if not input_image:
+            return None, "Please upload an image."
+        if not edit_prompt.strip():
+            return None, "Please describe how you want to edit the image."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = ImageService(client=client)
+
+        try:
+            progress(0, desc="Processing image...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                image_url = f"file://{input_image}"
+
+                images = loop.run_until_complete(
+                    service.edit_image(
+                        image_url=image_url,
+                        edit_prompt=edit_prompt,
+                        strength=strength,
+                        on_progress=on_progress
+                    )
+                )
+
+                if images:
+                    image_path = loop.run_until_complete(
+                        service.download_image(images[0])
+                    )
+                    return image_path, "Image edited successfully!"
+                else:
+                    return None, "No edited image was generated. Please try again."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def generate_video(
+        prompt: str,
+        duration: int,
+        style: str,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle text-to-video generation.
+
+        Returns:
+            Tuple of (video_path, status_message)
+        """
+        if not prompt.strip():
+            return None, "Please enter a description for your video."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = VideoService(client=client)
+
+        try:
+            progress(0, desc="Generating video...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                videos = loop.run_until_complete(
+                    service.generate_video(
+                        prompt=prompt,
+                        duration=int(duration),
+                        style=style,
+                        on_progress=on_progress
+                    )
+                )
+
+                if videos:
+                    video_path = loop.run_until_complete(
+                        service.download_video(videos[0])
+                    )
+                    return video_path, "Video generated successfully!"
+                else:
+                    return None, "No video was generated. Please try a different prompt."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()
+
+    @staticmethod
+    def animate_image(
+        input_image: str,
+        motion_prompt: str,
+        duration: int,
+        api_key: str = "",
+        progress: gr.Progress = gr.Progress()
+    ) -> Tuple[Optional[str], str]:
+        """
+        Handle image-to-video animation.
+
+        Returns:
+            Tuple of (video_path, status_message)
+        """
+        if not input_image:
+            return None, "Please upload an image."
+        if not motion_prompt.strip():
+            return None, "Please describe the motion you want."
+        if not api_key.strip():
+            return None, "Please enter your API key in the Settings section."
+
+        client = StackNetClient(api_key=api_key.strip())
+        service = VideoService(client=client)
+
+        try:
+            progress(0, desc="Animating image...")
+
+            def on_progress(value: float, message: str):
+                progress(value, desc=message)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                image_url = f"file://{input_image}"
+
+                videos = loop.run_until_complete(
+                    service.animate_image(
+                        image_url=image_url,
+                        motion_prompt=motion_prompt,
+                        duration=int(duration),
+                        on_progress=on_progress
+                    )
+                )
+
+                if videos:
+                    video_path = loop.run_until_complete(
+                        service.download_video(videos[0])
+                    )
+                    return video_path, "Image animated successfully!"
+                else:
+                    return None, "No video was generated. Please try again."
+
+            finally:
+                loop.close()
+
+        except Exception as e:
+            return None, format_error(e)
+
+        finally:
+            service.cleanup()

src/ui/tabs.py

@@ -0,0 +1,340 @@
+"""
+Gradio Tab Definitions
+
+Defines all 6 tabs for the StackNetdemo application.
+"""
+
+import gradio as gr
+
+
+def create_text_to_music_tab():
+    """Create the Text to Music tab components."""
+    with gr.Column():
+        gr.Markdown("### Generate original music from a text description")
+
+        prompt = gr.Textbox(
+            label="Describe your music",
+            placeholder="e.g., upbeat jazz with piano and saxophone, cheerful summer vibes",
+            lines=3
+        )
+
+        with gr.Row():
+            tags = gr.Textbox(
+                label="Genre/Style Tags",
+                placeholder="jazz, piano, instrumental",
+                scale=2
+            )
+            instrumental = gr.Checkbox(
+                label="Instrumental Only",
+                value=False,
+                scale=1
+            )
+
+        lyrics = gr.Textbox(
+            label="Lyrics (optional)",
+            placeholder="Write your lyrics here...",
+            lines=4,
+            visible=True
+        )
+
+        title = gr.Textbox(
+            label="Song Title (optional)",
+            placeholder="My Song"
+        )
+
+        generate_btn = gr.Button("Generate Music", variant="primary", size="lg")
+
+        status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+        output_audio = gr.Audio(label="Generated Music", type="filepath")
+
+    # Toggle lyrics visibility based on instrumental checkbox
+    instrumental.change(
+        fn=lambda x: gr.update(visible=not x),
+        inputs=[instrumental],
+        outputs=[lyrics],
+        api_name=None
+    )
+
+    return {
+        "prompt": prompt,
+        "tags": tags,
+        "instrumental": instrumental,
+        "lyrics": lyrics,
+        "title": title,
+        "generate_btn": generate_btn,
+        "status": status,
+        "output_audio": output_audio
+    }
+
+
+def create_music_to_music_tab():
+    """Create the Music to Music tab with sub-tabs for Cover and Stems."""
+    with gr.Tabs() as sub_tabs:
+        # Cover Song Sub-tab
+        with gr.Tab("Create Cover"):
+            with gr.Column():
+                gr.Markdown("### Create music from reference audio (Diffusion)")
+
+                cover_audio_input = gr.Audio(
+                    label="Upload Audio",
+                    type="filepath"
+                )
+
+                cover_style_prompt = gr.Textbox(
+                    label="Style Direction",
+                    placeholder="e.g., rock version with electric guitar, female vocalist",
+                    lines=2
+                )
+
+                cover_tags = gr.Textbox(
+                    label="Style Tags",
+                    placeholder="rock, electric guitar"
+                )
+
+                cover_title = gr.Textbox(
+                    label="Title (optional)",
+                    placeholder="My Song"
+                )
+
+                cover_btn = gr.Button("Create", variant="primary", size="lg")
+
+                cover_status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+                cover_output = gr.Audio(label="Song", type="filepath")
+
+        # Extract Stems Sub-tab
+        with gr.Tab("Extract Stems"):
+            with gr.Column():
+                gr.Markdown("### Separate audio into individual stems")
+
+                stems_audio_input = gr.Audio(
+                    label="Upload Audio",
+                    type="filepath"
+                )
+
+                stems_btn = gr.Button("Extract Stems", variant="primary", size="lg")
+
+                stems_status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+                gr.Markdown("**Extracted Stems:**")
+                with gr.Row():
+                    vocals_output = gr.Audio(label="Vocals", type="filepath")
+                    drums_output = gr.Audio(label="Drums", type="filepath")
+                with gr.Row():
+                    bass_output = gr.Audio(label="Bass", type="filepath")
+                    other_output = gr.Audio(label="Other", type="filepath")
+
+    return {
+        # Cover components
+        "cover_audio_input": cover_audio_input,
+        "cover_style_prompt": cover_style_prompt,
+        "cover_tags": cover_tags,
+        "cover_title": cover_title,
+        "cover_btn": cover_btn,
+        "cover_status": cover_status,
+        "cover_output": cover_output,
+        # Stems components
+        "stems_audio_input": stems_audio_input,
+        "stems_btn": stems_btn,
+        "stems_status": stems_status,
+        "vocals_output": vocals_output,
+        "drums_output": drums_output,
+        "bass_output": bass_output,
+        "other_output": other_output
+    }
+
+
+def create_text_to_image_tab():
+    """Create the Text to Image tab components."""
+    with gr.Column():
+        gr.Markdown("### Generate images from a text description")
+
+        prompt = gr.Textbox(
+            label="Describe your image",
+            placeholder="e.g., a serene mountain landscape at sunset with snow-capped peaks",
+            lines=3
+        )
+
+        with gr.Row():
+            style = gr.Dropdown(
+                label="Style",
+                choices=["Photorealistic", "Digital Art", "Oil Painting", "Watercolor", "Sketch", "Anime"],
+                value="Photorealistic",
+                scale=1
+            )
+            aspect_ratio = gr.Dropdown(
+                label="Aspect Ratio",
+                choices=["1:1", "16:9", "9:16", "4:3", "3:4"],
+                value="1:1",
+                scale=1
+            )
+
+        generate_btn = gr.Button("Generate Image", variant="primary", size="lg")
+
+        status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+        output_image = gr.Image(label="Generated Image", type="filepath")
+
+    return {
+        "prompt": prompt,
+        "style": style,
+        "aspect_ratio": aspect_ratio,
+        "generate_btn": generate_btn,
+        "status": status,
+        "output_image": output_image
+    }
+
+
+def create_image_to_image_tab():
+    """Create the Image to Image tab components."""
+    with gr.Column():
+        gr.Markdown("### Transform or edit an existing image")
+
+        with gr.Row():
+            input_image = gr.Image(
+                label="Upload Image",
+                type="filepath",
+                scale=1
+            )
+
+            with gr.Column(scale=1):
+                edit_prompt = gr.Textbox(
+                    label="Edit Instructions",
+                    placeholder="e.g., add dramatic sunset lighting, make it look like a painting",
+                    lines=3
+                )
+
+                strength = gr.Slider(
+                    label="Edit Strength",
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.5,
+                    step=0.1
+                )
+
+        edit_btn = gr.Button("Transform Image", variant="primary", size="lg")
+
+        status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+        output_image = gr.Image(label="Transformed Image", type="filepath")
+
+    return {
+        "input_image": input_image,
+        "edit_prompt": edit_prompt,
+        "strength": strength,
+        "edit_btn": edit_btn,
+        "status": status,
+        "output_image": output_image
+    }
+
+
+def create_text_to_video_tab():
+    """Create the Text to Video tab components."""
+    with gr.Column():
+        gr.Markdown("### Generate videos from a text description")
+
+        prompt = gr.Textbox(
+            label="Describe your video",
+            placeholder="e.g., a drone shot flying over a tropical beach at golden hour",
+            lines=3
+        )
+
+        with gr.Row():
+            duration = gr.Slider(
+                label="Duration (seconds)",
+                minimum=3,
+                maximum=30,
+                value=10,
+                step=1,
+                scale=1
+            )
+            style = gr.Dropdown(
+                label="Style",
+                choices=["Cinematic", "Animation", "Documentary", "Abstract"],
+                value="Cinematic",
+                scale=1
+            )
+
+        generate_btn = gr.Button("Generate Video", variant="primary", size="lg")
+
+        status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+        output_video = gr.Video(label="Generated Video")
+
+    return {
+        "prompt": prompt,
+        "duration": duration,
+        "style": style,
+        "generate_btn": generate_btn,
+        "status": status,
+        "output_video": output_video
+    }
+
+
+def create_image_to_video_tab():
+    """Create the Image to Video tab components."""
+    with gr.Column():
+        gr.Markdown("### Animate a static image into video")
+
+        with gr.Row():
+            input_image = gr.Image(
+                label="Upload Image",
+                type="filepath",
+                scale=1
+            )
+
+            with gr.Column(scale=1):
+                motion_prompt = gr.Textbox(
+                    label="Motion Description",
+                    placeholder="e.g., gentle zoom in, clouds moving slowly, water rippling",
+                    lines=3
+                )
+
+                duration = gr.Slider(
+                    label="Duration (seconds)",
+                    minimum=3,
+                    maximum=15,
+                    value=5,
+                    step=1
+                )
+
+        animate_btn = gr.Button("Animate Image", variant="primary", size="lg")
+
+        status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+        output_video = gr.Video(label="Animated Video")
+
+    return {
+        "input_image": input_image,
+        "motion_prompt": motion_prompt,
+        "duration": duration,
+        "animate_btn": animate_btn,
+        "status": status,
+        "output_video": output_video
+    }
+
+
+def create_all_tabs():
+    """Create all tabs and return component references."""
+    tabs = {}
+
+    with gr.Tab("Text to Music", id="text-to-music"):
+        tabs["text_to_music"] = create_text_to_music_tab()
+
+    with gr.Tab("Music to Music", id="music-to-music"):
+        tabs["music_to_music"] = create_music_to_music_tab()
+
+    with gr.Tab("Text to Image", id="text-to-image"):
+        tabs["text_to_image"] = create_text_to_image_tab()
+
+    with gr.Tab("Image to Image", id="image-to-image"):
+        tabs["image_to_image"] = create_image_to_image_tab()
+
+    with gr.Tab("Text to Video", id="text-to-video"):
+        tabs["text_to_video"] = create_text_to_video_tab()
+
+    with gr.Tab("Image to Video", id="image-to-video"):
+        tabs["image_to_video"] = create_image_to_video_tab()
+
+    return tabs