fix error

app.py

@@ -1,35 +1,32 @@
-import gradio as gr
 import os
-import requests
-import random
-import tempfile
-import json
 import time
+import json
 import shutil
+import random
+import tempfile
+import requests
 
+import gradio as gr
 from openai import OpenAI
 from smolagents import CodeAgent, MCPClient, tool
-from huggingface_hub import InferenceClient  # still imported if you need it elsewhere
-from moviepy.editor import VideoFileClip, ImageClip, CompositeVideoClip, AudioFileClip
-from PIL import Image, ImageDraw, ImageFont
-import numpy as np
-from elevenlabs import ElevenLabs, VoiceSettings
+from huggingface_hub import InferenceClient
 
-# Import our new Gemini quote generator
 from quote_generator_gemini import HybridQuoteGenerator
 
-# Initialize clients
+# -------------------------------------------------
+# GLOBAL CLIENTS & CONFIG
+# -------------------------------------------------
+
 openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-elevenlabs_client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
 
-# Initialize Hybrid Quote Generator (Gemini + OpenAI fallback)
+# Hybrid Gemini + OpenAI quote generator
 hybrid_quote_generator = HybridQuoteGenerator(
     gemini_key=os.getenv("GEMINI_API_KEY"),
-    openai_client=openai_client
+    openai_client=openai_client,
 )
 
-# Initialize MCP Client (connecting to existing MCP server)
+# Optional MCP client (non-fatal if not installed)
 try:
     mcp_client = MCPClient("https://abidlabs-mcp-tools.hf.space")
     mcp_enabled = True
@@ -37,42 +34,43 @@ except Exception as e:
     print(f"MCP initialization warning: {e}")
     mcp_enabled = False
 
-# -----------------------
+
+# -------------------------------------------------
 # TOOLS
-# -----------------------
+# -------------------------------------------------
 
 @tool
 def generate_quote_tool(niche: str, style: str) -> str:
     """
-    Generate a powerful inspirational quote using Gemini AI with variety tracking.
-    Falls back to OpenAI if Gemini is unavailable.
-    
+    Generate a unique inspirational quote using the HybridQuoteGenerator.
+
     Args:
-        niche: The category of quote (Motivation, Business, Fitness, etc.)
-        style: The visual style (Cinematic, Nature, Urban, Minimal, Abstract)
-    
+        niche: The category of the quote (e.g. Motivation, Fitness, Mindfulness).
+        style: The visual style or aesthetic (e.g. Cinematic, Nature, Urban).
+
     Returns:
-        A powerful, unique quote string
+        A single quote string. If an error occurs, returns a human-readable error message.
     """
     try:
-        result = hybrid_quote_generator.generate_quote(niche, style, prefer_gemini=True)
-        
-        if result["success"]:
+        result = hybrid_quote_generator.generate_quote(
+            niche=niche,
+            style=style,
+            prefer_gemini=True,
+        )
+        if result.get("success"):
             quote = result["quote"]
-            source = result["source"]
-            
-            # Log which generator was used
+            source = result.get("source")
             if source == "gemini":
                 stats = result.get("stats", {})
-                print(f"✨ Generated with Gemini (Total: {stats.get('total_quotes_generated', 0)})")
+                print(
+                    f"✨ Generated with Gemini. Total quotes: "
+                    f"{stats.get('total_quotes_generated', 0)}"
+                )
             else:
-                print(f"✨ Generated with OpenAI (fallback)")
-            
+                print("✨ Generated with OpenAI fallback")
             return quote
         else:
-            error_msg = result.get("error", "Unknown error")
-            return f"Error generating quote: {error_msg}"
-    
+            return f"Error generating quote: {result.get('error', 'Unknown error')}"
     except Exception as e:
         return f"Error generating quote: {str(e)}"
 
@@ -80,322 +78,253 @@ def generate_quote_tool(niche: str, style: str) -> str:
 @tool
 def search_pexels_video_tool(style: str, niche: str) -> dict:
     """
-    Search and fetch a matching video from Pexels based on style and niche.
-    
+    Search and fetch a portrait video from Pexels that matches a style and niche.
+
     Args:
-        style: Visual style (Cinematic, Nature, Urban, Minimal, Abstract)
-        niche: Content niche (Motivation, Business, Fitness, etc.)
-    
+        style: Visual style (e.g. Cinematic, Nature, Urban, Minimal, Abstract).
+        niche: Content niche (e.g. Motivation, Business/Entrepreneurship, Fitness).
+
     Returns:
-        Dictionary with video_url, search_query, and pexels_url
+        A dictionary with:
+            - success: Whether a suitable video was found.
+            - video_url: The direct link to the video file (or None).
+            - search_query: The query used to search.
+            - pexels_url: The Pexels page URL (or None).
+            - error: Optional error message on failure.
     """
-    
-    # Intelligent search strategy mapping
     search_strategies = {
         "Motivation": {
             "Cinematic": ["person climbing mountain", "running sunrise", "achievement success"],
             "Nature": ["sunrise mountain peak", "ocean waves powerful", "forest light"],
             "Urban": ["city skyline dawn", "person running city", "urban success"],
             "Minimal": ["minimal motivation", "single person silhouette", "clean inspiring"],
-            "Abstract": ["light rays hope", "particles rising", "abstract energy"]
+            "Abstract": ["light rays hope", "particles rising", "abstract energy"],
         },
         "Business/Entrepreneurship": {
             "Cinematic": ["business cityscape", "office modern", "handshake deal"],
             "Nature": ["growth plant", "river flowing", "sunrise new beginning"],
             "Urban": ["city business", "office skyline", "modern workspace"],
             "Minimal": ["desk minimal", "workspace clean", "simple office"],
-            "Abstract": ["network connections", "growth chart", "abstract progress"]
+            "Abstract": ["network connections", "growth chart", "abstract progress"],
         },
         "Fitness": {
             "Cinematic": ["athlete training", "gym workout", "running outdoor"],
             "Nature": ["outdoor workout", "mountain hiking", "beach running"],
             "Urban": ["city running", "urban fitness", "street workout"],
             "Minimal": ["gym minimal", "simple workout", "clean fitness"],
-            "Abstract": ["energy motion", "strength power", "dynamic movement"]
+            "Abstract": ["energy motion", "strength power", "dynamic movement"],
         },
         "Mindfulness": {
             "Cinematic": ["meditation sunset", "peaceful landscape", "calm water"],
             "Nature": ["forest peaceful", "calm lake", "zen garden"],
             "Urban": ["city peaceful morning", "quiet street", "urban calm"],
             "Minimal": ["minimal zen", "simple meditation", "clean peaceful"],
-            "Abstract": ["calm waves", "gentle motion", "soft particles"]
+            "Abstract": ["calm waves", "gentle motion", "soft particles"],
         },
         "Stoicism": {
             "Cinematic": ["ancient architecture", "statue philosopher", "timeless landscape"],
             "Nature": ["mountain strong", "oak tree", "stone nature"],
             "Urban": ["classical building", "statue city", "ancient modern"],
             "Minimal": ["stone minimal", "simple strong", "pillar minimal"],
-            "Abstract": ["marble texture", "stone abstract", "timeless pattern"]
+            "Abstract": ["marble texture", "stone abstract", "timeless pattern"],
         },
         "Leadership": {
             "Cinematic": ["team meeting", "leader speaking", "group collaboration"],
             "Nature": ["eagle flying", "lion pride", "mountain top"],
             "Urban": ["office leadership", "boardroom", "city leadership"],
             "Minimal": ["chess pieces", "simple leadership", "clean professional"],
-            "Abstract": ["network leader", "connection points", "guiding light"]
+            "Abstract": ["network leader", "connection points", "guiding light"],
         },
         "Love & Relationships": {
             "Cinematic": ["couple sunset", "romance beautiful", "love cinematic"],
             "Nature": ["couple nature", "romantic sunset", "peaceful together"],
             "Urban": ["couple city", "romance urban", "love city lights"],
             "Minimal": ["hands holding", "simple love", "minimal romance"],
-            "Abstract": ["hearts flowing", "love particles", "connection abstract"]
-        }
+            "Abstract": ["hearts flowing", "love particles", "connection abstract"],
+        },
     }
-    
-    # Get queries for this niche + style combination
+
     queries = search_strategies.get(niche, {}).get(style, ["aesthetic nature"])
-    
+
     try:
-        headers = {"Authorization": PEXELS_API_KEY}
-        
-        # Pick a random query for variety
+        headers = {"Authorization": PEXELS_API_KEY} if PEXELS_API_KEY else {}
         query = random.choice(queries)
-        
-        url = f"https://api.pexels.com/videos/search?query={query}&per_page=15&orientation=portrait"
+
+        url = (
+            f"https://api.pexels.com/videos/search"
+            f"?query={query}&per_page=15&orientation=portrait"
+        )
         response = requests.get(url, headers=headers)
         data = response.json()
-        
+
         if "videos" in data and len(data["videos"]) > 0:
-            # Pick a random video from results
             video = random.choice(data["videos"][:10])
             video_files = video.get("video_files", [])
-            
-            # Find portrait/vertical video
-            portrait_videos = [vf for vf in video_files if vf.get("width", 0) < vf.get("height", 0)]
-            
+
+            portrait_videos = [
+                vf
+                for vf in video_files
+                if vf.get("width", 0) < vf.get("height", 0)
+            ]
+
             if portrait_videos:
                 selected = random.choice(portrait_videos)
                 return {
+                    "success": True,
                     "video_url": selected.get("link"),
                     "search_query": query,
                     "pexels_url": video.get("url"),
-                    "success": True
                 }
-            
-            # Fallback to any HD video
+
             if video_files:
                 return {
+                    "success": True,
                     "video_url": video_files[0].get("link"),
                     "search_query": query,
                     "pexels_url": video.get("url"),
-                    "success": True
                 }
-        
+
         return {
+            "success": False,
             "video_url": None,
             "search_query": query,
             "pexels_url": None,
-            "success": False,
-            "error": "No suitable videos found"
+            "error": "No suitable videos found",
         }
-    
+
     except Exception as e:
         return {
+            "success": False,
             "video_url": None,
             "search_query": "",
             "pexels_url": None,
-            "success": False,
-            "error": str(e)
+            "error": str(e),
         }
 
 
 @tool
-def generate_voice_commentary_tool(quote_text: str, niche: str, output_path: str) -> dict:
+def create_quote_video_tool(video_url: str, quote_text: str, output_path: str) -> dict:
     """
-    Generate insightful voice commentary explaining the deeper meaning of the quote.
-    Uses Gemini to create thoughtful explanation, then ElevenLabs to voice it.
-    This adds VALUE - not just reading what's already on screen.
+    Create a quote video by calling a Modal endpoint that overlays text on a background video.
+
+    Args:
+        video_url: Direct URL of the background video (e.g. from Pexels).
+        quote_text: The quote text to be overlaid on the video.
+        output_path: Local file path where the resulting video should be saved.
+
+    Returns:
+        A dictionary with:
+            - success: Whether the generation succeeded.
+            - output_path: The saved video path on disk (or None).
+            - message: A human-readable status message.
     """
+    modal_endpoint = os.getenv("MODAL_ENDPOINT_URL")
+
+    if not modal_endpoint:
+        print("ℹ️ MODAL_ENDPOINT_URL not configured, cannot generate video.")
+        return {
+            "success": False,
+            "output_path": None,
+            "message": (
+                "Modal endpoint not configured. Set MODAL_ENDPOINT_URL to use remote "
+                "video generation (modal deploy modal_video_processing.py)."
+            ),
+        }
+
     try:
-        import google.generativeai as genai
-        
-        explanation_prompt = f"""Given this {niche} quote:
-
-"{quote_text}"
-
-Write a brief, insightful voice-over commentary that explains the deeper meaning or practical wisdom.
-
-Requirements:
-- 2-3 sentences maximum
-- Around 25-35 words total
-- Spoken naturally (like a wise mentor)
-- Add insight that isn't obvious from reading
-- Make it thought-provoking
-- Don't start with "This quote..." - dive into the insight
-
-Return ONLY the commentary, nothing else."""
-        genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
-        model = genai.GenerativeModel('gemini-1.5-flash')
-        
-        response = model.generate_content(
-            explanation_prompt,
-            generation_config={
-                "temperature": 0.7,
-                "max_output_tokens": 100
-            }
+        print("🚀 Processing on Modal (fast!)...")
+        response = requests.post(
+            modal_endpoint,
+            json={
+                "video_url": video_url,
+                "quote_text": quote_text,
+            },
+            timeout=120,
         )
-        
-        explanation = response.text.strip().strip('"').strip("'")
-        print(f"📝 Commentary: {explanation}")
-        
-        audio = elevenlabs_client.text_to_speech.convert(
-            text=explanation,
-            voice_id="pNInz6obpgDQGcFmaJgB",
-            model_id="eleven_multilingual_v2",
-            voice_settings=VoiceSettings(
-                stability=0.6,
-                similarity_boost=0.8,
-                style=0.6,
-                use_speaker_boost=True
-            )
-        )
-        
-        with open(output_path, 'wb') as f:
-            for chunk in audio:
-                f.write(chunk)
-        
+
+        if response.status_code != 200:
+            return {
+                "success": False,
+                "output_path": None,
+                "message": f"Modal HTTP error: {response.status_code}",
+            }
+
+        result = response.json()
+        if not result.get("success"):
+            return {
+                "success": False,
+                "output_path": None,
+                "message": f"Modal error: {result.get('error', 'Unknown error')}",
+            }
+
+        import base64
+
+        video_b64 = result["video"]
+        video_bytes = base64.b64decode(video_b64)
+
+        with open(output_path, "wb") as f:
+            f.write(video_bytes)
+
+        size_mb = result.get("size_mb", len(video_bytes) / 1024 / 1024)
+        print(f"✅ Modal processing complete! {size_mb:.2f}MB")
+
         return {
             "success": True,
             "output_path": output_path,
-            "explanation": explanation,
-            "message": "Voice commentary created!"
+            "message": f"Video created via Modal (~{size_mb:.2f}MB).",
         }
-    
+
     except Exception as e:
         return {
             "success": False,
             "output_path": None,
-            "explanation": None,
-            "message": f"Error creating commentary: {str(e)}"
+            "message": f"Error calling Modal: {str(e)}",
         }
 
 
-@tool
-def create_quote_video_tool(video_url: str, quote_text: str, output_path: str, audio_path: str = None) -> dict:
-    """
-    Create a final quote video by overlaying text on the background video.
-    Uses Modal for fast processing (4-8x faster) with local fallback.
-    Optionally adds voice narration audio.
-    """
-    modal_endpoint = os.getenv("MODAL_ENDPOINT_URL")
-    
-    if modal_endpoint:
-        try:
-            import base64
-            
-            print("🚀 Processing on Modal (fast!)...")
-            
-            audio_b64 = None
-            if audio_path and os.path.exists(audio_path):
-                with open(audio_path, 'rb') as f:
-                    audio_bytes = f.read()
-                    audio_b64 = base64.b64encode(audio_bytes).decode()
-                print(f"   🎤 Including voice commentary audio ({len(audio_bytes)} bytes)")
-            
-            response = requests.post(
-                modal_endpoint,
-                json={
-                    "video_url": video_url,
-                    "quote_text": quote_text,
-                    "audio_b64": audio_b64
-                },
-                timeout=120
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                
-                if result.get("success"):
-                    video_b64 = result["video"]
-                    video_bytes = base64.b64decode(video_b64)
-                    
-                    with open(output_path, 'wb') as f:
-                        f.write(video_bytes)
-                    
-                    print(f"✅ Modal processing complete! {result['size_mb']:.2f}MB")
-                    
-                    return {
-                        "success": True,
-                        "output_path": output_path,
-                        "message": f"Video created via Modal in ~20s ({result['size_mb']:.2f}MB)"
-                    }
-                else:
-                    print(f"⚠️ Modal returned error: {result.get('error', 'Unknown')}")
-            else:
-                print(f"⚠️ Modal HTTP error: {response.status_code}")
-            
-            print("⚠️ Modal failed, falling back to local processing...")
-            
-        except requests.Timeout:
-            print(f"⚠️ Modal timeout after 120s, falling back to local...")
-        except Exception as e:
-            print(f"⚠️ Modal error: {e}, falling back to local processing...")
-    else:
-        print("ℹ️ MODAL_ENDPOINT_URL not configured, using local processing")
-    
-    # For hackathon deploy: avoid heavy local MoviePy on Spaces to prevent hangs
-    print("🔧 Local processing disabled on this deployment.")
-    return {
-        "success": False,
-        "output_path": None,
-        "message": "Local processing disabled - please configure Modal for video generation. Deploy Modal with: modal deploy modal_video_processing.py"
-    }
-
-# -----------------------
+# -------------------------------------------------
 # AGENT INITIALIZATION
-# -----------------------
+# -------------------------------------------------
 
 def initialize_agent():
-    """Initialize the CodeAgent with MCP capabilities"""
+    """Initialize the CodeAgent with optional MCP client."""
     try:
-        # Use Hugging Face Inference API for the agent's LLM
         hf_token = os.getenv("HF_TOKEN")
-        # If you have a specific model, you can set HF_MODEL_ID in your Space secrets
-        hf_model_id = os.getenv("HF_MODEL_ID")  # e.g. "mistralai/Mixtral-8x7B-Instruct-v0.1"
-        
-        if hf_model_id:
-            model = InferenceClient(model=hf_model_id, token=hf_token)
-        else:
-            # Fallback: rely on default model configured on the Space / org
-            model = InferenceClient(token=hf_token)
-        
+        model = InferenceClient(token=hf_token)
+
         agent = CodeAgent(
-            tools=[
-                generate_quote_tool,
-                search_pexels_video_tool,
-                generate_voice_commentary_tool,
-                create_quote_video_tool,
-            ],
+            tools=[generate_quote_tool, search_pexels_video_tool, create_quote_video_tool],
             model=model,
             additional_authorized_imports=[
-                "requests",
-                "openai",
-                "random",
-                "tempfile",
                 "os",
-                "google.generativeai",
+                "time",
                 "json",
+                "random",
+                "tempfile",
+                "requests",
             ],
             max_steps=15,
         )
-        
+
         if mcp_enabled:
             agent.mcp_clients = [mcp_client]
-        
+
         return agent, None
     except Exception as e:
         return None, f"Agent initialization error: {str(e)}"
 
+
 agent, agent_error = initialize_agent()
 
-# -----------------------
+
+# -------------------------------------------------
 # PIPELINES
-# -----------------------
+# -------------------------------------------------
 
-def mcp_agent_pipeline(niche, style, num_variations=1):
+def mcp_agent_pipeline(niche: str, style: str, num_variations: int = 1):
     """
     MAIN PIPELINE: uses smolagents CodeAgent.run to plan & call tools.
+
     The agent:
       - calls generate_quote_tool
       - calls search_pexels_video_tool multiple times
@@ -403,22 +332,22 @@ def mcp_agent_pipeline(niche, style, num_variations=1):
       - returns JSON with status_log + video_paths
     """
     base_log = ["🤖 **MCP AGENT RUN**"]
-    
+
     if agent_error or agent is None:
         base_log.append(f"❌ Agent initialization failed: {agent_error}")
         base_log.append("🔄 Falling back to direct tool pipeline...")
         status, vids = fallback_pipeline(niche, style, num_variations)
         return "\n".join(base_log + [status]), vids
-    
+
     try:
         output_dir = "/tmp/quote_videos"
         gallery_dir = "/data/gallery_videos"
         os.makedirs(output_dir, exist_ok=True)
         os.makedirs(gallery_dir, exist_ok=True)
-        
+
         timestamp = int(time.time())
-        base_prefix = f"{output_dir}/agent_{timestamp}_v"
-        
+        base_prefix = os.path.join(output_dir, f"agent_{timestamp}_v")
+
         user_task = f"""
 You are an autonomous Python agent helping creators generate short vertical quote videos.
 
@@ -426,81 +355,84 @@ Niche: {niche}
 Style: {style}
 Number of variations: {num_variations}
 
-You have these TOOLS already available in this environment:
+You have these TOOLS available:
 
 1. generate_quote_tool(niche: str, style: str) -> str
-   - Returns a unique quote as plain text.
+   - Returns a single quote as plain text.
 
 2. search_pexels_video_tool(style: str, niche: str) -> dict
-   - Returns a dict with at least:
-     - "video_url": str or None
+   - Returns a dict with:
      - "success": bool
+     - "video_url": str or None
 
-3. create_quote_video_tool(video_url: str, quote_text: str, output_path: str, audio_path: str | None = None) -> dict
-   - Downloads a video, overlays the quote, and writes a video file to output_path.
-   - Returns a dict with at least:
+3. create_quote_video_tool(video_url: str, quote_text: str, output_path: str) -> dict
+   - Writes a video file to output_path and returns a dict with:
      - "success": bool
-     - "output_path": str | None
-
-You MAY also have access to external MCP tools through your mcp_clients attribute; you can call them if helpful (e.g. logging, inspiration, etc.), but they are optional.
+     - "output_path": str or None
 
 Your job:
 
-1. Call generate_quote_tool once with the given niche and style to obtain quote_text.
-2. For each variation i from 1 to {num_variations}, call search_pexels_video_tool(style, niche) to get a background video.
-3. For each successful search result, create an output path EXACTLY as:
-   "{base_prefix}{{i}}.mp4"  where i is the variation index (1-based).
-4. Call create_quote_video_tool(video_url, quote_text, output_path) for each variation.
-5. Only keep variations where create_quote_video_tool returns success == True and a non-empty output_path.
-6. Build a human-readable status_log string summarizing what you did (which tools were called, success/failures).
-7. Return ONLY a valid JSON object of the form:
+1. Call generate_quote_tool once to obtain quote_text.
+2. For each variation i from 1 to {num_variations}:
+   - Call search_pexels_video_tool(style, niche).
+   - If it succeeds, compute output_path exactly as:
+     "{base_prefix}{{i}}.mp4"
+   - Call create_quote_video_tool(video_url, quote_text, output_path).
+3. Collect only variations where create_quote_video_tool returns success == True and a non-empty output_path.
+4. Build a human-readable status_log string summarizing:
+   - Which tools you called
+   - How many videos succeeded or failed
+5. Return ONLY a valid JSON object of the form:
 
 {{
   "status_log": "multi-line human readable description of what you did",
   "video_paths": [
     "{base_prefix}1.mp4",
-    "... only include paths that actually succeeded ..."
+    "... only paths that actually succeeded ..."
   ]
 }}
 
 CRITICAL:
-- Do not wrap the JSON in markdown or backticks.
-- Do not add extra keys.
-- Do not print anything besides the JSON.
+- Do NOT wrap the JSON in markdown or backticks.
+- Do NOT add extra keys.
+- Do NOT print anything except the JSON object as your final answer.
 """
+
         agent_result = agent.run(user_task)
-        
+
         try:
             parsed = json.loads(agent_result)
         except Exception as parse_err:
-            raise ValueError(f"Agent output was not valid JSON: {parse_err}\nRaw: {agent_result[:500]}")
-        
+            raise ValueError(
+                f"Agent output was not valid JSON: {parse_err}\n"
+                f"Raw agent output (first 500 chars): {agent_result[:500]}"
+            )
+
         status_log = parsed.get("status_log", "")
         video_paths = parsed.get("video_paths", [])
-        
-        # Keep only existing paths
+
         valid_paths = [
-            p for p in video_paths
-            if isinstance(p, str) and os.path.exists(p)
+            p for p in video_paths if isinstance(p, str) and os.path.exists(p)
         ]
-        
+
         if not valid_paths:
-            raise ValueError("Agent returned no valid video paths or files do not exist on disk.")
-        
-        # Copy to gallery directory
+            raise ValueError("Agent returned no valid video paths or files not found.")
+
         for idx, path in enumerate(valid_paths):
             try:
                 filename = os.path.basename(path)
-                gallery_path = os.path.join(gallery_dir, f"gallery_{timestamp}_v{idx+1}_{filename}")
+                gallery_path = os.path.join(
+                    gallery_dir,
+                    f"gallery_{timestamp}_v{idx+1}_{filename}",
+                )
                 shutil.copy2(path, gallery_path)
             except Exception as e:
                 print(f"⚠️ Failed to copy to gallery for {path}: {e}")
-        
+
         full_status = "\n".join(base_log + [status_log])
         return full_status, valid_paths[:3]
-    
+
     except Exception as e:
-        # Hard fallback if anything goes wrong
         fallback_status, fallback_videos = fallback_pipeline(niche, style, num_variations)
         combined_status = "\n".join(
             base_log
@@ -509,57 +441,54 @@ CRITICAL:
         return combined_status, fallback_videos
 
 
-def fallback_pipeline(niche, style, num_variations=1):
-    """Fallback pipeline if MCP agent fails: direct tool calls."""
+def fallback_pipeline(niche: str, style: str, num_variations: int = 1):
+    """Fallback pipeline: direct tool calls without agent planning."""
     status_log = []
     status_log.append("🔄 **FALLBACK MODE (Direct Tool Execution)**\n")
-    
-    # Generate quote
-    status_log.append("🧠 Generating quote with Gemini...")
+
+    status_log.append("🧠 Generating quote with HybridQuoteGenerator...")
     quote = generate_quote_tool(niche, style)
-    
-    if "Error" in quote:
+
+    if isinstance(quote, str) and quote.startswith("Error generating quote"):
         return "\n".join(status_log) + f"\n❌ {quote}", []
-    
+
     status_log.append("   ✅ Quote generated\n")
-    
-    # Search videos
+
     status_log.append(f"🔍 Searching for {num_variations} videos...")
     video_results = []
-    for i in range(num_variations):
-        video_result = search_pexels_video_tool(style, niche)
-        if video_result["success"]:
-            video_results.append(video_result)
-    
+    for _ in range(num_variations):
+        vr = search_pexels_video_tool(style, niche)
+        if vr.get("success"):
+            video_results.append(vr)
+
     if not video_results:
-        return "\n".join(status_log) + "\n❌ No videos found", []
-    
+        status_log.append("❌ No videos found\n")
+        return "\n".join(status_log), []
+
     status_log.append(f"   ✅ Found {len(video_results)} videos\n")
-    
-    # Create videos
-    status_log.append("🎬 Creating videos...")
+
+    status_log.append("🎬 Creating videos via Modal...")
     output_dir = "/tmp/quote_videos"
     gallery_dir = "/data/gallery_videos"
     os.makedirs(output_dir, exist_ok=True)
     os.makedirs(gallery_dir, exist_ok=True)
-    
+
     timestamp = int(time.time())
     created_videos = []
-    
-    for i, video_result in enumerate(video_results):
+
+    for i, vr in enumerate(video_results):
         output_filename = f"quote_video_v{i+1}_{timestamp}.mp4"
         output_path = os.path.join(output_dir, output_filename)
-        
+
         creation_result = create_quote_video_tool(
-            video_result["video_url"],
-            quote,
-            output_path,
-            None
+            video_url=vr["video_url"],
+            quote_text=quote,
+            output_path=output_path,
         )
-        
-        if creation_result["success"]:
+
+        if creation_result.get("success"):
             created_videos.append(creation_result["output_path"])
-            
+
             gallery_filename = f"gallery_{timestamp}_v{i+1}.mp4"
             gallery_path = os.path.join(gallery_dir, gallery_filename)
             try:
@@ -569,162 +498,182 @@ def fallback_pipeline(niche, style, num_variations=1):
         else:
             error_msg = creation_result.get("message", "Unknown error")
             status_log.append(f"   ❌ Video {i+1} error: {error_msg}")
-    
+
     if not created_videos:
-        return "\n".join(status_log) + "\n❌ Video creation failed", []
-    
+        status_log.append("❌ Video creation failed\n")
+        return "\n".join(status_log), []
+
     status_log.append(f"   ✅ Created {len(created_videos)} videos!\n")
     status_log.append("🎬 **COMPLETE!**")
-    
+
     return "\n".join(status_log), created_videos
 
-# -----------------------
-# GRADIO UI
-# -----------------------
 
-with gr.Blocks(title="AIQuoteClipGenerator - MCP + Gemini Edition", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
+# -------------------------------------------------
+# GRADIO UI
+# -------------------------------------------------
+
+with gr.Blocks(
+    title="AIQuoteClipGenerator - MCP + Gemini Edition",
+    theme=gr.themes.Soft(),
+) as demo:
+    gr.Markdown(
+        """
     # 🎬 AIQuoteClipGenerator
     ### MCP-Powered with Gemini AI
-    
+
     **Key Features:**
-    - 🌟 **Gemini AI:** No more repetitive quotes! Smart variety tracking
-    - 🔗 **MCP Server Usage:** smolagents CodeAgent + MCP client  
-    - 🛠️ **4 Custom Tools:** Quote + Video search + Voice (optional) + Video creation
-    - 🤖 **Agent Reasoning:** Autonomous task execution via CodeAgent.run
-    - ⚡ **Modal Processing:** 4-8x faster video creation
-    - 🎨 **Multiple Variations:** Get different video styles
-    """)
-    
-    # Example Gallery
+    - 🌟 **Gemini AI** with quote-history to avoid repetition
+    - 🤖 **smolagents CodeAgent** for planning & tool-use
+    - 🔗 **MCP Client Ready** (uses external MCP tools if available)
+    - 🎥 **Modal** for fast video rendering
+    - 🎨 Generate multiple vertical quote video variations
+    """
+    )
+
     with gr.Accordion("📸 Example Gallery - Recent Videos", open=True):
-        gr.Markdown("See what others have created! Updates automatically after generation.")
-        
+        gr.Markdown(
+            "See what others (or you) have generated. Auto-updates after each run."
+        )
+
         with gr.Row():
-            gallery_video1 = gr.Video(label="", height=300, show_label=False, interactive=False)
-            gallery_video2 = gr.Video(label="", height=300, show_label=False, interactive=False)
-            gallery_video3 = gr.Video(label="", height=300, show_label=False, interactive=False)
-        
+            gallery_video1 = gr.Video(height=300, show_label=False, interactive=False)
+            gallery_video2 = gr.Video(height=300, show_label=False, interactive=False)
+            gallery_video3 = gr.Video(height=300, show_label=False, interactive=False)
+
         with gr.Row():
-            gallery_video4 = gr.Video(label="", height=300, show_label=False, interactive=False)
-            gallery_video5 = gr.Video(label="", height=300, show_label=False, interactive=False)
-            gallery_video6 = gr.Video(label="", height=300, show_label=False, interactive=False)
-    
+            gallery_video4 = gr.Video(height=300, show_label=False, interactive=False)
+            gallery_video5 = gr.Video(height=300, show_label=False, interactive=False)
+            gallery_video6 = gr.Video(height=300, show_label=False, interactive=False)
+
     def load_gallery_videos():
         gallery_output_dir = "/data/gallery_videos"
         os.makedirs(gallery_output_dir, exist_ok=True)
-        
+
         import glob
+
         existing_videos = sorted(
-            glob.glob(f"{gallery_output_dir}/*.mp4"),
+            glob.glob(os.path.join(gallery_output_dir, "*.mp4")),
             key=os.path.getmtime,
-            reverse=True
+            reverse=True,
         )[:6]
-        
+
         videos = [None] * 6
-        for i, video_path in enumerate(existing_videos):
+        for i, path in enumerate(existing_videos):
             if i < 6:
-                videos[i] = video_path
-        
+                videos[i] = path
         return videos
-    
+
     gr.Markdown("---")
     gr.Markdown("## 🎯 Generate Your Own Quote Video")
-    
+
     with gr.Row():
         with gr.Column():
             gr.Markdown("### 🎯 Input")
             niche = gr.Dropdown(
                 choices=[
                     "Motivation",
-                    "Business/Entrepreneurship", 
+                    "Business/Entrepreneurship",
                     "Fitness",
                     "Mindfulness",
                     "Stoicism",
                     "Leadership",
-                    "Love & Relationships"
+                    "Love & Relationships",
                 ],
                 label="📂 Select Niche",
-                value="Motivation"
+                value="Motivation",
             )
-            
+
             style = gr.Dropdown(
-                choices=[
-                    "Cinematic",
-                    "Nature", 
-                    "Urban",
-                    "Minimal",
-                    "Abstract"
-                ],
+                choices=["Cinematic", "Nature", "Urban", "Minimal", "Abstract"],
                 label="🎨 Visual Style",
-                value="Cinematic"
+                value="Cinematic",
             )
-            
+
             num_variations = gr.Slider(
                 minimum=1,
                 maximum=3,
-                value=1,
                 step=1,
+                value=1,
                 label="🎬 Number of Video Variations",
-                info="Generate multiple versions to choose from"
+                info="Generate multiple versions to choose from",
             )
-            
-            generate_btn = gr.Button("🤖 Run MCP Agent with Gemini", variant="primary", size="lg")
-        
+
+            generate_btn = gr.Button(
+                "🤖 Run MCP Agent with Gemini", variant="primary", size="lg"
+            )
+
         with gr.Column():
             gr.Markdown("### 📊 MCP Agent Activity Log")
-            output = gr.Textbox(label="Agent Status", lines=20, show_label=False)
-    
+            output = gr.Textbox(lines=20, show_label=False)
+
     with gr.Row():
         gr.Markdown("### ✨ Your Quote Videos")
-    
+
     with gr.Row():
         video1 = gr.Video(label="Video 1", visible=True, height=500)
         video2 = gr.Video(label="Video 2", visible=False, height=500)
         video3 = gr.Video(label="Video 3", visible=False, height=500)
-    
-    gr.Markdown("""
+
+    gr.Markdown(
+        """
     ---
     ### ✨ Features
-    - 🌟 **Gemini AI** - Eliminates repetitive quotes with smart history tracking
-    - 🎨 **Multiple Variations** - Get 1-3 different videos to choose from
-    - ⚡ **Modal Processing** - 4-8x faster with serverless compute
-    - 🤖 **Real Agent** - smolagents CodeAgent orchestrates tool calls
-    - 🔗 **MCP Usage** - Agent wired with MCP client for external tools
-    
+    - 🌟 **Gemini-powered** quote variety (history-aware)
+    - 🎨 Multiple aesthetic video variations
+    - ⚡ **Modal**-accelerated rendering
+    - 🤖 **smolagents** CodeAgent for autonomous tool-calling
+    - 🔗 Optional MCP integration via MCPClient
+
     ### 🏆 Hackathon: MCP 1st Birthday
     **Track:** Track 2 - MCP in Action  
-    **Category:** Productivity Tools  
-    **Built with:** Gradio + smolagents + Gemini + OpenAI + Pexels + Modal + ElevenLabs + MCP
-    """)
-    
+    **Category:** Productivity / Creator Tools  
+    **Stack:** Gradio · smolagents · Gemini · OpenAI · Pexels · Modal · MCP
+    """
+    )
+
     def process_and_display(niche, style, num_variations):
-        status, videos = mcp_agent_pipeline(niche, style, int(num_variations))
-        
+        status, videos = mcp_agent_pipeline(
+            niche=str(niche),
+            style=str(style),
+            num_variations=int(num_variations),
+        )
+
         v1 = videos[0] if len(videos) > 0 else None
         v2 = videos[1] if len(videos) > 1 else None
         v3 = videos[2] if len(videos) > 2 else None
-        
+
         gallery_vids = load_gallery_videos()
-        
+
         return [status, v1, v2, v3] + gallery_vids
-    
+
     generate_btn.click(
-        process_and_display, 
-        inputs=[niche, style, num_variations], 
+        process_and_display,
+        inputs=[niche, style, num_variations],
         outputs=[
-            output, video1, video2, video3,
-            gallery_video1, gallery_video2, gallery_video3,
-            gallery_video4, gallery_video5, gallery_video6
-        ]
+            output,
+            video1,
+            video2,
+            video3,
+            gallery_video1,
+            gallery_video2,
+            gallery_video3,
+            gallery_video4,
+            gallery_video5,
+            gallery_video6,
+        ],
     )
-    
+
     demo.load(
         load_gallery_videos,
         outputs=[
-            gallery_video1, gallery_video2, gallery_video3,
-            gallery_video4, gallery_video5, gallery_video6
-        ]
+            gallery_video1,
+            gallery_video2,
+            gallery_video3,
+            gallery_video4,
+            gallery_video5,
+            gallery_video6,
+        ],
     )
 
 if __name__ == "__main__":