Upload app.py

app.py

@@ -3,28 +3,190 @@ import requests
 import os
 import json
 import uuid
-from datetime import datetime
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+from fastapi import Request
 
-# Load Suno API key from environment variable
-SUNO_KEY = os.environ.get("SUNO_KEY", os.environ.get("SunoKey", ""))
+# Load Suno API key - using SunoKey as you specified
+SUNO_KEY = os.environ.get("SunoKey", "")
+if not SUNO_KEY:
+    print("⚠️ Warning: SunoKey environment variable not set!")
 
-# In production, use your actual public URL
-# For Spaces, get from environment or use ngrok for local testing
-SPACE_URL = os.environ.get("SPACE_URL", "https://your-username.hf.space")
+# Configuration
+POLLING_INTERVAL = 5  # seconds
+MAX_POLLING_TIME = 300  # 5 minutes max
+WEBHOOK_TIMEOUT = 30  # seconds to wait for webhook before starting polling
 
-# Store tasks with timestamps
-tasks_db = {}
+# For Hugging Face Spaces - get the public URL
+SPACE_NAME = os.environ.get("SPACE_NAME", "")
+AUTHOR_NAME = os.environ.get("AUTHOR_NAME", "")
+if SPACE_NAME and AUTHOR_NAME:
+    SPACE_URL = f"https://{AUTHOR_NAME}-{SPACE_NAME}.hf.space"
+elif os.environ.get("SYSTEM") == "spaces":
+    # Try to construct from environment
+    SPACE_URL = f"https://{os.environ.get('SPACE_ID', '').replace('_', '-')}.hf.space"
+else:
+    SPACE_URL = "http://localhost:7860"
 
-def generate_lyrics(prompt, callBackUrl=""):
-    """Submit lyrics generation task with callback URL"""
+# Task storage with automatic cleanup
+class TaskManager:
+    def __init__(self):
+        self.tasks: Dict[str, dict] = {}
+        self._lock = threading.Lock()
+    
+    def create_task(self, prompt: str, callback_url: str = "") -> str:
+        """Create a new task and start background monitoring"""
+        task_id = str(uuid.uuid4())[:8]
+        
+        with self._lock:
+            self.tasks[task_id] = {
+                "id": task_id,
+                "prompt": prompt,
+                "callback_url": callback_url,
+                "api_task_id": None,
+                "status": "created",
+                "result": None,
+                "error": None,
+                "created_at": datetime.now(),
+                "last_checked": None,
+                "method": None,  # 'webhook' or 'polling'
+                "webhook_received": False,
+                "polling_started": False,
+                "completed": False
+            }
+        
+        return task_id
+    
+    def update_task(self, task_id: str, **kwargs):
+        """Update task properties"""
+        with self._lock:
+            if task_id in self.tasks:
+                self.tasks[task_id].update(kwargs)
+                self.tasks[task_id]["last_checked"] = datetime.now()
+    
+    def get_task(self, task_id: str) -> Optional[dict]:
+        """Get task by ID"""
+        with self._lock:
+            return self.tasks.get(task_id)
+    
+    def get_all_tasks(self):
+        """Get all tasks"""
+        with self._lock:
+            return list(self.tasks.values())
+    
+    def cleanup_old_tasks(self, hours=24):
+        """Remove tasks older than specified hours"""
+        cutoff = datetime.now() - timedelta(hours=hours)
+        with self._lock:
+            to_delete = [
+                task_id for task_id, task in self.tasks.items()
+                if task["created_at"] < cutoff
+            ]
+            for task_id in to_delete:
+                del self.tasks[task_id]
+            return len(to_delete)
+
+task_manager = TaskManager()
+
+# Background polling thread
+class PollingThread(threading.Thread):
+    def __init__(self, task_id: str):
+        super().__init__(daemon=True)
+        self.task_id = task_id
+        self.stop_event = threading.Event()
+    
+    def run(self):
+        """Poll Suno API for task completion"""
+        task = task_manager.get_task(self.task_id)
+        if not task or not task.get("api_task_id"):
+            return
+        
+        api_task_id = task["api_task_id"]
+        start_time = datetime.now()
+        
+        while not self.stop_event.is_set():
+            # Check if we've been polling too long
+            if (datetime.now() - start_time).seconds > MAX_POLLING_TIME:
+                task_manager.update_task(
+                    self.task_id,
+                    status="timeout",
+                    error="Polling timeout - task took too long",
+                    completed=True
+                )
+                break
+            
+            try:
+                # Poll the API
+                result = _poll_suno_api(api_task_id)
+                
+                if result["status"] == "completed":
+                    task_manager.update_task(
+                        self.task_id,
+                        status="completed",
+                        result=result.get("data"),
+                        method="polling",
+                        completed=True
+                    )
+                    break
+                elif result["status"] == "failed":
+                    task_manager.update_task(
+                        self.task_id,
+                        status="failed",
+                        error=result.get("error", "Unknown error"),
+                        completed=True
+                    )
+                    break
+                else:
+                    # Still processing
+                    task_manager.update_task(
+                        self.task_id,
+                        status=result["status"]
+                    )
+                    
+                    # Wait before next poll
+                    self.stop_event.wait(POLLING_INTERVAL)
+            
+            except Exception as e:
+                task_manager.update_task(
+                    self.task_id,
+                    status="polling_error",
+                    error=f"Polling error: {str(e)}",
+                    last_checked=datetime.now()
+                )
+                # Wait before retry
+                self.stop_event.wait(POLLING_INTERVAL * 2)
+    
+    def stop(self):
+        self.stop_event.set()
+
+def _poll_suno_api(api_task_id: str) -> dict:
+    """Internal function to poll Suno API"""
     if not SUNO_KEY:
-        return "❌ Error: SUNO_KEY environment variable not set"
+        raise ValueError("SunoKey not configured")
     
-    # Generate unique task ID
-    task_id = str(uuid.uuid4())[:8]
+    url = f"https://api.sunoapi.org/api/v1/lyrics/details?taskId={api_task_id}"
+    headers = {"Authorization": f"Bearer {SUNO_KEY}"}
+    
+    response = requests.get(url, headers=headers, timeout=30)
+    response.raise_for_status()
+    data = response.json()
     
-    # Use provided callback URL or default to your Space URL
-    callback_url = callBackUrl or f"{SPACE_URL}/callback"
+    if data.get("code") == 200 and "data" in data:
+        task_data = data["data"]
+        return {
+            "status": task_data.get("status", "unknown"),
+            "data": task_data.get("data"),
+            "error": task_data.get("error")
+        }
+    else:
+        raise Exception(data.get("msg", "API polling failed"))
+
+def submit_to_suno(prompt: str, task_id: str, callback_url: str = "") -> dict:
+    """Submit task to Suno API with error handling"""
+    if not SUNO_KEY:
+        raise ValueError("SunoKey environment variable not set")
     
     url = "https://api.sunoapi.org/api/v1/lyrics"
     headers = {
@@ -32,276 +194,494 @@ def generate_lyrics(prompt, callBackUrl=""):
         "Content-Type": "application/json"
     }
     
+    # If no callback_url provided, use a dummy one
+    # Suno requires a URL, but we'll rely on polling
+    effective_callback = callback_url or "https://dummy.webhook.url/not-used"
+    
     payload = {
         "prompt": prompt,
-        "callBackUrl": callback_url,
-        "customTaskId": task_id  # Optional: track your own ID
+        "callBackUrl": effective_callback
     }
     
     try:
-        resp = requests.post(url, headers=headers, json=payload, timeout=30)
-        data = resp.json()
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        data = response.json()
         
-        if resp.status_code == 200 and data.get("code") == 200:
+        if data.get("code") == 200 and "data" in data:
             api_task_id = data["data"]["taskId"]
             
-            # Store task info
-            tasks_db[task_id] = {
+            # Start background polling with delay (give webhook a chance)
+            polling_thread = PollingThread(task_id)
+            
+            # Start polling after WEBHOOK_TIMEOUT seconds
+            def start_polling():
+                time.sleep(WEBHOOK_TIMEOUT)
+                task = task_manager.get_task(task_id)
+                if task and not task.get("webhook_received") and not task.get("polling_started"):
+                    task_manager.update_task(task_id, polling_started=True)
+                    polling_thread.start()
+            
+            threading.Thread(target=start_polling, daemon=True).start()
+            
+            return {
+                "success": True,
                 "api_task_id": api_task_id,
-                "prompt": prompt,
-                "status": "submitted",
-                "submitted_at": datetime.now().isoformat(),
-                "callback_received": False,
-                "lyrics": None
+                "message": "Task submitted successfully"
+            }
+        else:
+            error_msg = data.get("msg", "Unknown API error")
+            return {
+                "success": False,
+                "error": f"API Error: {error_msg}",
+                "code": data.get("code")
             }
+    
+    except requests.exceptions.Timeout:
+        return {
+            "success": False,
+            "error": "Request timeout - Suno API is not responding"
+        }
+    except requests.exceptions.ConnectionError:
+        return {
+            "success": False,
+            "error": "Connection error - Check your internet connection"
+        }
+    except requests.exceptions.HTTPError as e:
+        return {
+            "success": False,
+            "error": f"HTTP Error: {e.response.status_code if e.response else 'Unknown'}"
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Unexpected error: {str(e)}"
+        }
+
+def generate_lyrics(prompt: str, use_callback: bool = True):
+    """Main function to generate lyrics with hybrid approach"""
+    if not prompt or not prompt.strip():
+        return "❌ Please enter a prompt"
+    
+    if not SUNO_KEY:
+        return "❌ Error: SunoKey environment variable not set. Please configure it in Settings."
+    
+    # Create task
+    callback_url = f"{SPACE_URL}/callback" if use_callback else ""
+    task_id = task_manager.create_task(prompt, callback_url)
+    
+    try:
+        # Submit to Suno
+        result = submit_to_suno(prompt, task_id, callback_url)
+        
+        if result["success"]:
+            # Update task with API task ID
+            task_manager.update_task(
+                task_id,
+                api_task_id=result["api_task_id"],
+                status="submitted",
+                method="webhook" if use_callback else "polling"
+            )
             
-            return f"""✅ Task Submitted!
-Your Task ID: {task_id}
-API Task ID: {api_task_id}
-Callback URL: {callback_url}
+            return f"""✅ **Task Submitted Successfully!**
+
+**Your Task ID:** `{task_id}`
+**API Task ID:** `{result['api_task_id']}`
+**Method:** {'Webhook + Polling Fallback' if use_callback else 'Polling Only'}
+**Status:** Submitted - Processing...
 
-📝 Prompt: {prompt}
+📝 **Prompt:** {prompt[:100]}{'...' if len(prompt) > 100 else ''}
 
-⏳ Processing... The results will be sent to the callback URL.
-You can also poll manually using your Task ID above."""
+⏳ **What happens next:**
+1. Task submitted to Suno AI
+2. {'Webhook expected within 30 seconds' if use_callback else 'Polling started'}
+3. Results will appear automatically
+4. You can also check status manually
+
+🆔 **Save this Task ID:** {task_id}"""
         
         else:
-            error_msg = data.get("msg", "Unknown error")
-            return f"❌ API Error: {error_msg} (Code: {data.get('code')})"
+            # Submission failed
+            task_manager.update_task(
+                task_id,
+                status="submission_failed",
+                error=result["error"],
+                completed=True
+            )
             
+            return f"""❌ **Submission Failed**
+
+**Task ID:** `{task_id}`
+**Error:** {result['error']}
+
+💡 **Possible solutions:**
+• Check your SunoKey is valid
+• Try a different prompt
+• Wait a few minutes and try again"""
+    
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        error_msg = str(e)
+        task_manager.update_task(
+            task_id,
+            status="exception",
+            error=error_msg,
+            completed=True
+        )
+        return f"❌ Exception occurred: {error_msg}"
 
-def poll_task(task_id):
-    """Manual polling as fallback"""
-    if not SUNO_KEY:
-        return "❌ Error: SUNO_KEY not configured"
+def check_task_status(task_id: str):
+    """Check status of a specific task"""
+    if not task_id or not task_id.strip():
+        return "❌ Please enter a Task ID"
     
-    if task_id not in tasks_db:
-        return "❌ Task ID not found. Please submit a task first."
+    task = task_manager.get_task(task_id)
+    if not task:
+        return f"❌ Task ID `{task_id}` not found. Please check and try again."
     
-    task_info = tasks_db[task_id]
-    api_task_id = task_info["api_task_id"]
+    status = task["status"]
+    method = task.get("method", "unknown")
+    elapsed = (datetime.now() - task["created_at"]).seconds
     
-    url = f"https://api.sunoapi.org/api/v1/lyrics/details?taskId={api_task_id}"
-    headers = {"Authorization": f"Bearer {SUNO_KEY}"}
+    # Format status display
+    if task["completed"]:
+        if status == "completed" and task["result"]:
+            return format_lyrics_result(task["result"], task_id, method)
+        elif status == "failed" or status == "error":
+            return f"""❌ **Task Failed**
+
+**Task ID:** `{task_id}`
+**Status:** {status}
+**Error:** {task.get('error', 'Unknown error')}
+**Method:** {method}
+**Elapsed:** {elapsed} seconds
+
+💡 Please try generating again."""
+        else:
+            return f"📊 **Task Completed with status:** {status}"
     
-    try:
-        resp = requests.get(url, headers=headers, timeout=30)
-        data = resp.json()
+    else:
+        # Task still in progress
+        status_icon = {
+            "created": "🆕",
+            "submitted": "⏳",
+            "processing": "🔄",
+            "pending": "⏱️"
+        }.get(status, "❓")
         
-        if resp.status_code == 200 and data.get("code") == 200:
-            task_data = data["data"]
-            status = task_data.get("status", "unknown")
-            tasks_db[task_id]["status"] = status
-            
-            if status == "completed" and "data" in task_data:
-                lyrics_data = task_data["data"]
-                tasks_db[task_id]["lyrics"] = lyrics_data
-                tasks_db[task_id]["callback_received"] = True
-                
-                return format_lyrics(lyrics_data, task_id)
-            elif status == "failed":
-                return f"❌ Task failed: {task_data.get('error', 'Unknown error')}"
-            else:
-                return f"⏳ Status: {status}\nLast checked: {datetime.now().strftime('%H:%M:%S')}"
-        else:
-            return f"❌ Polling error: {data.get('msg', 'Unknown error')}"
-            
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return f"""{status_icon} **Task In Progress**
+
+**Task ID:** `{task_id}`
+**Status:** {status}
+**Method:** {method}
+**Elapsed:** {elapsed} seconds
+**Last checked:** {task.get('last_checked', 'Never')}
+
+⏳ **Processing...** Please check back in a few seconds.
 
-def format_lyrics(lyrics_data, task_id):
+🔁 **Auto-refreshing in 5 seconds...**"""
+
+def format_lyrics_result(lyrics_data, task_id, method):
     """Format lyrics for display"""
-    output = [f"🎵 **Task {task_id} - Generated Lyrics**", ""]
+    if not lyrics_data:
+        return "✅ Task completed but no lyrics data received"
+    
+    output = [f"🎵 **Generated Lyrics (Task: {task_id})**", ""]
     
     for i, item in enumerate(lyrics_data, 1):
         title = item.get('title', f'Variant {i}')
         text = item.get('text', 'No lyrics generated')
         
-        output.append(f"**Variant {i}: {title}**")
+        output.append(f"### Variant {i}: {title}")
         output.append("```")
         output.append(text)
         output.append("```")
         output.append("---")
     
-    output.append(f"\n✅ Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    output.append(f"\n✅ **Completed via:** {method}")
+    output.append(f"🕒 **Finished at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
     return "\n".join(output)
 
-def list_tasks():
-    """Show all submitted tasks"""
-    if not tasks_db:
-        return "No tasks submitted yet."
-    
-    output = ["📋 **Submitted Tasks:**", ""]
-    for task_id, info in tasks_db.items():
-        status_icon = "✅" if info["callback_received"] else "⏳"
-        output.append(f"{status_icon} **{task_id}** - {info['status']}")
-        output.append(f"   Prompt: {info['prompt'][:50]}...")
-        output.append(f"   Submitted: {info['submitted_at']}")
+def list_all_tasks():
+    """List all tasks with status"""
+    tasks = task_manager.get_all_tasks()
+    if not tasks:
+        return "📭 No tasks found. Generate some lyrics first!"
+    
+    # Sort by creation time (newest first)
+    tasks.sort(key=lambda x: x["created_at"], reverse=True)
+    
+    output = ["📋 **All Tasks**", ""]
+    
+    for task in tasks:
+        # Status icon
+        if task["completed"]:
+            icon = "✅" if task["status"] == "completed" else "❌"
+        else:
+            icon = "⏳"
+        
+        elapsed = (datetime.now() - task["created_at"]).seconds
+        method = task.get("method", "unknown")
+        
+        output.append(f"{icon} **{task['id']}** - {task['status']}")
+        output.append(f"   Prompt: {task['prompt'][:50]}...")
+        output.append(f"   Method: {method} | Age: {elapsed}s")
+        
+        if task.get("error"):
+            output.append(f"   Error: {task['error'][:50]}...")
+        
         output.append("")
     
+    # Cleanup old tasks periodically
+    cleaned = task_manager.cleanup_old_tasks(hours=1)
+    if cleaned:
+        output.append(f"🧹 Cleaned up {cleaned} old tasks")
+    
     return "\n".join(output)
 
-# WEBHOOK ENDPOINT (for receiving callbacks)
-def webhook_callback(request: gr.Request):
-    """Handle incoming webhook from Suno API"""
+# Webhook handler function for Gradio 6.0+
+async def webhook_handler(request: Request):
+    """Handle incoming webhook from Suno"""
     try:
-        # Try to get JSON data
-        data = request.json()
+        # Get the raw request body
+        body = await request.body()
+        print(f"📥 Webhook received: {request.method}")
         
-        if not data:
+        # Try to parse JSON
+        try:
+            data = json.loads(body.decode('utf-8'))
+        except:
             # Try form data
-            data = dict(request.form)
+            form_data = await request.form()
+            data = dict(form_data) if form_data else {}
         
-        print(f"📥 Received webhook: {json.dumps(data, indent=2)}")
+        print(f"📦 Webhook data received")
         
-        # Extract task info from webhook
-        # Suno API format might vary - adjust based on actual response
-        if "data" in data and "taskId" in data["data"]:
-            api_task_id = data["data"]["taskId"]
-            status = data["data"].get("status", "unknown")
+        # Extract task info (adjust based on Suno's actual format)
+        if isinstance(data, dict):
+            print(f"Data structure: {json.dumps(data, indent=2)[:500]}...")
             
-            # Find our task by API task ID
-            for task_id, task_info in tasks_db.items():
-                if task_info["api_task_id"] == api_task_id:
-                    task_info["status"] = status
-                    task_info["callback_received"] = True
-                    
-                    if status == "completed" and "data" in data["data"]:
-                        task_info["lyrics"] = data["data"]["data"]
-                        print(f"✅ Lyrics received for task {task_id}")
-                    
-                    return {"status": "success", "message": f"Updated task {task_id}"}
-        
-        return {"status": "error", "message": "Task not found"}
+            # Try different possible response formats
+            api_data = None
+            if "data" in data:
+                api_data = data["data"]
+            elif "task" in data:
+                api_data = data["task"]
+            elif "result" in data:
+                api_data = data["result"]
+            
+            if api_data and isinstance(api_data, dict):
+                api_task_id = api_data.get("taskId") or api_data.get("id")
+                status = api_data.get("status", "unknown")
+                
+                if api_task_id:
+                    # Find task by API task ID
+                    for task in task_manager.get_all_tasks():
+                        if task.get("api_task_id") == api_task_id:
+                            task_id = task["id"]
+                            
+                            if status == "completed":
+                                lyrics_data = api_data.get("data") or api_data.get("lyrics") or api_data.get("result")
+                                task_manager.update_task(
+                                    task_id,
+                                    status="completed",
+                                    result=lyrics_data,
+                                    webhook_received=True,
+                                    method="webhook",
+                                    completed=True
+                                )
+                                print(f"✅ Webhook completed task {task_id}")
+                                return {"status": "success", "task_id": task_id}
+                            
+                            elif status == "failed":
+                                error_msg = api_data.get("error", "Unknown error")
+                                task_manager.update_task(
+                                    task_id,
+                                    status="failed",
+                                    error=error_msg,
+                                    webhook_received=True,
+                                    completed=True
+                                )
+                                return {"status": "error", "task_id": task_id, "error": error_msg}
+                            
+                            else:
+                                task_manager.update_task(task_id, status=status)
+                                return {"status": "updated", "task_id": task_id}
         
+        return {"status": "no_match", "message": "Task not found in database"}
+    
     except Exception as e:
-        print(f"❌ Webhook error: {e}")
+        print(f"❌ Webhook error: {str(e)}")
         return {"status": "error", "message": str(e)}
 
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Suno Lyrics Generator") as app:
+# Create Gradio app
+with gr.Blocks() as app:
     gr.Markdown("# 🎵 Suno AI Lyrics Generator")
-    gr.Markdown("Generate song lyrics with webhook support")
+    gr.Markdown("Hybrid solution: Webhooks with automatic polling fallback")
     
     with gr.Tabs():
-        with gr.TabItem("🎤 Generate"):
+        with gr.TabItem("✨ Generate"):
             with gr.Row():
-                with gr.Column():
-                    prompt = gr.Textbox(
+                with gr.Column(scale=2):
+                    prompt_input = gr.Textbox(
                         label="Lyrics Prompt",
-                        placeholder="A romantic ballad about stargazing...",
-                        lines=3
+                        placeholder="A jazz song about rainy nights in Tokyo...",
+                        lines=4
                     )
                     
-                    # Optional: Custom callback URL
-                    callback_url = gr.Textbox(
-                        label="Callback URL (Optional)",
-                        value=f"{SPACE_URL}/callback",
-                        info="Where Suno should send results. Leave as default for Spaces."
+                    use_webhook = gr.Checkbox(
+                        label="Enable webhooks (recommended)",
+                        value=True,
+                        info="If webhook fails, automatic polling will start"
                     )
                     
-                    submit_btn = gr.Button("✨ Generate Lyrics", variant="primary")
+                    submit_btn = gr.Button("🚀 Generate Lyrics", variant="primary", scale=1)
                     
-                    gr.Markdown("### ℹ️ Instructions:")
+                    gr.Markdown("### 📋 Instructions:")
                     gr.Markdown("""
-                    1. Enter your lyrics prompt
-                    2. Click Generate
+                    1. Enter your lyrics idea
+                    2. Submit (webhooks enabled by default)
                     3. Save your Task ID
-                    4. Check status in the "Poll Tasks" tab
-                    5. Results will arrive via webhook automatically
+                    4. Check status in the "Status" tab
+                    5. Results arrive automatically
+                    
+                    **🔧 Behind the scenes:**
+                    - Webhook attempted first
+                    - If no response in 30s, polling starts
+                    - Polling continues until completion
+                    - Results available in both tabs
                     """)
                 
-                with gr.Column():
-                    output = gr.Textbox(
+                with gr.Column(scale=3):
+                    output_result = gr.Markdown(
                         label="Submission Result",
-                        lines=10,
-                        interactive=False
+                        value="Your results will appear here..."
                     )
             
             submit_btn.click(
                 generate_lyrics,
-                inputs=[prompt, callback_url],
-                outputs=output
+                inputs=[prompt_input, use_webhook],
+                outputs=output_result
             )
         
-        with gr.TabItem("🔄 Poll Tasks"):
+        with gr.TabItem("🔍 Check Status"):
             with gr.Row():
                 with gr.Column():
                     task_id_input = gr.Textbox(
-                        label="Your Task ID",
-                        placeholder="Enter the Task ID from generation step"
+                        label="Task ID",
+                        placeholder="Enter your Task ID (e.g., a1b2c3d4)"
                     )
-                    poll_btn = gr.Button("🔍 Check Status", variant="primary")
                     
-                    gr.Markdown("---")
-                    refresh_btn = gr.Button("📋 List All Tasks")
-                    tasks_list = gr.Textbox(label="All Tasks", lines=10)
+                    with gr.Row():
+                        check_btn = gr.Button("🔎 Check Status", variant="primary")
+                        refresh_btn = gr.Button("🔄 Auto-refresh", variant="secondary")
+                        list_all_btn = gr.Button("📋 All Tasks")
+                    
+                    task_list_output = gr.Textbox(
+                        label="All Tasks",
+                        lines=10,
+                        interactive=False
+                    )
                 
                 with gr.Column():
-                    poll_result = gr.Textbox(
+                    status_output = gr.Markdown(
                         label="Task Status",
-                        lines=15,
-                        interactive=False
+                        value="Enter a Task ID and click Check Status"
                     )
             
-            poll_btn.click(
-                poll_task,
+            # Event handlers
+            check_btn.click(
+                check_task_status,
                 inputs=task_id_input,
-                outputs=poll_result
+                outputs=status_output
             )
             
             refresh_btn.click(
-                list_tasks,
+                check_task_status,
+                inputs=task_id_input,
+                outputs=status_output
+            )
+            
+            list_all_btn.click(
+                list_all_tasks,
                 inputs=None,
-                outputs=tasks_list
+                outputs=task_list_output
             )
         
-        with gr.TabItem("⚙️ Webhook Info"):
-            gr.Markdown("### 🌐 Webhook Configuration")
+        with gr.TabItem("⚙️ Settings & Info"):
+            gr.Markdown("### ⚙️ Configuration")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**🔑 API Status:**")
+                    api_status = gr.Markdown(
+                        value=f"✅ SunoKey: {'Configured' if SUNO_KEY else '❌ NOT SET'}"
+                    )
+                    
+                    gr.Markdown(f"**🌐 Space URL:** `{SPACE_URL}`")
+                    
+                    gr.Markdown("**🔄 Webhook Endpoint:**")
+                    webhook_info = gr.Textbox(
+                        value=f"{SPACE_URL}/callback",
+                        interactive=False
+                    )
+                
+                with gr.Column():
+                    gr.Markdown("**📊 Statistics:**")
+                    stats_text = gr.Textbox(
+                        value=f"Active tasks: {len(task_manager.get_all_tasks())}",
+                        interactive=False
+                    )
+                    
+                    cleanup_btn = gr.Button("🧹 Cleanup Old Tasks", variant="secondary")
+                    cleanup_output = gr.Textbox(label="Cleanup Result", interactive=False)
+            
+            gr.Markdown("### 📚 How It Works:")
             gr.Markdown(f"""
-            **Your Webhook URL:** `{SPACE_URL}/callback`
+            **Hybrid Approach:**
+            1. Submit with webhook URL (required by Suno API)
+            2. Wait 30 seconds for webhook response
+            3. If no webhook, start background polling
+            4. Poll every 5 seconds until completion
+            5. Return results via polling if webhook fails
             
-            **For Local Development:**
-            1. Use [ngrok](https://ngrok.com/): `ngrok http 7860`
-            2. Update callback URL: `https://your-ngrok-url.ngrok.io/callback`
+            **Your Webhook URL:** `{SPACE_URL}/callback`
             
-            **For Hugging Face Spaces:**
-            - The URL above should work automatically
-            - Make sure your Space is public or has network access
+            **Error Recovery:**
+            • Network issues → automatic retry
+            • API errors → informative messages
+            • Timeouts → fallback to polling
+            • All errors → logged for debugging
             """)
             
-            webhook_status = gr.Textbox(
-                label="Last Webhook Status",
-                value="No webhooks received yet",
-                lines=5
+            cleanup_btn.click(
+                lambda: f"Cleaned {task_manager.cleanup_old_tasks(hours=1)} old tasks",
+                inputs=None,
+                outputs=cleanup_output
             )
-    
-    # Register webhook endpoint
-    # Note: In production, you'd set up proper route handling
-    # For Gradio, we can simulate with a POST endpoint
-    app.post("/callback")(webhook_callback)
 
-# Launch configuration
+# Add the webhook route using the new Gradio 6.0 method
+app.add_api_route("/callback", webhook_handler, methods=["POST"])
+
+# For backward compatibility, also add a simple GET endpoint
+@app.get("/")
+def home():
+    return {"status": "running", "app": "Suno Lyrics Generator"}
+
+# Launch the app
 if __name__ == "__main__":
-    # For local testing with webhooks
-    import socket
-    
-    # Get local IP for ngrok compatibility
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        s.connect(("8.8.8.8", 80))
-        local_ip = s.getsockname()[0]
-        s.close()
-        print(f"🌐 Local IP: {local_ip}")
-        print(f"🌐 Webhook URL: http://{local_ip}:7860/callback")
-    except:
-        pass
+    print("🚀 Starting Suno Lyrics Generator...")
+    print(f"🔑 SunoKey: {'✅ Set' if SUNO_KEY else '❌ NOT SET'}")
+    print(f"🌐 Space URL: {SPACE_URL}")
+    print(f"🌐 Webhook endpoint: {SPACE_URL}/callback")
+    print(f"⏱️ Polling fallback: {WEBHOOK_TIMEOUT}s delay")
     
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        show_error=True,
+        debug=False,
+        title="Suno Lyrics Generator",
+        theme="soft"
     )