Update app.py

app.py

@@ -3,685 +3,401 @@ import requests
 import os
 import json
 import uuid
-import threading
 import time
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Dict, Optional
-from fastapi import Request
 
-# Load Suno API key - using SunoKey as you specified
+# Load Suno API key
 SUNO_KEY = os.environ.get("SunoKey", "")
 if not SUNO_KEY:
     print("⚠️ Warning: SunoKey environment variable not set!")
 
-# Configuration
-POLLING_INTERVAL = 5  # seconds
-MAX_POLLING_TIME = 300  # 5 minutes max
-WEBHOOK_TIMEOUT = 30  # seconds to wait for webhook before starting polling
+# Task storage
+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"
-
-# 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"""
+def generate_lyrics(prompt: str) -> str:
+    """Submit lyrics generation task to Suno API"""
     if not SUNO_KEY:
-        raise ValueError("SunoKey not configured")
-    
-    url = f"https://api.sunoapi.org/api/v1/lyrics/details?taskId={api_task_id}"
-    headers = {"Authorization": f"Bearer {SUNO_KEY}"}
+        return "❌ Error: SunoKey environment variable not set. Please add it in Space Settings."
     
-    response = requests.get(url, headers=headers, timeout=30)
-    response.raise_for_status()
-    data = response.json()
+    if not prompt or not prompt.strip():
+        return "❌ Please enter a lyrics prompt"
     
-    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")
+    # Generate task ID
+    task_id = str(uuid.uuid4())[:8]
     
+    # Prepare API request
     url = "https://api.sunoapi.org/api/v1/lyrics"
     headers = {
         "Authorization": f"Bearer {SUNO_KEY}",
         "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"
+    # Suno requires a callback URL, but we'll use a dummy one and rely on polling
+    dummy_callback = "https://dummy.callback.url/not-used"
     
     payload = {
         "prompt": prompt,
-        "callBackUrl": effective_callback
+        "callBackUrl": dummy_callback
     }
     
     try:
+        # Submit task
         response = requests.post(url, headers=headers, json=payload, timeout=30)
-        response.raise_for_status()
         data = response.json()
         
-        if data.get("code") == 200 and "data" in data:
+        if response.status_code == 200 and data.get("code") == 200:
             api_task_id = data["data"]["taskId"]
             
-            # 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,
+            # Store task information
+            tasks_db[task_id] = {
+                "id": task_id,
                 "api_task_id": api_task_id,
-                "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")
+                "prompt": prompt,
+                "status": "submitted",
+                "result": None,
+                "error": None,
+                "created_at": datetime.now().isoformat(),
+                "last_checked": None
             }
-    
-    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 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...
+**API Task ID:** `{api_task_id}`
 
 📝 **Prompt:** {prompt[:100]}{'...' if len(prompt) > 100 else ''}
 
-⏳ **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
+⏳ **Next Steps:**
+1. Task is now processing with Suno AI
+2. This usually takes 10-30 seconds
+3. Click **"Check Status"** tab to check progress
+4. Use your Task ID: `{task_id}`
 
-🆔 **Save this Task ID:** {task_id}"""
+💡 **Tip:** Save your Task ID to check results later!"""
         
         else:
-            # Submission failed
-            task_manager.update_task(
-                task_id,
-                status="submission_failed",
-                error=result["error"],
-                completed=True
-            )
-            
+            error_msg = data.get("msg", f"HTTP {response.status_code}")
             return f"""❌ **Submission Failed**
 
-**Task ID:** `{task_id}`
-**Error:** {result['error']}
+**Error:** {error_msg}
 
 💡 **Possible solutions:**
-• Check your SunoKey is valid
+• Check if your SunoKey is valid
 • Try a different prompt
-• Wait a few minutes and try again"""
+• Wait a few minutes and retry"""
     
+    except requests.exceptions.Timeout:
+        return "❌ Error: Request timeout - Suno API is not responding"
+    except requests.exceptions.ConnectionError:
+        return "❌ Error: Connection failed - Check your internet connection"
+    except requests.exceptions.HTTPError as e:
+        return f"❌ Error: HTTP {e.response.status_code if e.response else 'Unknown'}"
     except Exception as e:
-        error_msg = str(e)
-        task_manager.update_task(
-            task_id,
-            status="exception",
-            error=error_msg,
-            completed=True
-        )
-        return f"❌ Exception occurred: {error_msg}"
+        return f"❌ Error: {str(e)}"
 
-def check_task_status(task_id: str):
-    """Check status of a specific task"""
+def check_task_status(task_id: str) -> str:
+    """Check the status of a task using polling"""
     if not task_id or not task_id.strip():
         return "❌ Please enter a Task ID"
     
-    task = task_manager.get_task(task_id)
-    if not task:
-        return f"❌ Task ID `{task_id}` not found. Please check and try again."
+    if task_id not in tasks_db:
+        return f"❌ Task ID `{task_id}` not found. Please submit a task first."
     
-    status = task["status"]
-    method = task.get("method", "unknown")
-    elapsed = (datetime.now() - task["created_at"]).seconds
+    task = tasks_db[task_id]
+    api_task_id = task["api_task_id"]
+    
+    # Poll the Suno API
+    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**
+    try:
+        response = requests.get(url, headers=headers, timeout=30)
+        data = response.json()
+        
+        if response.status_code == 200 and data.get("code") == 200:
+            task_data = data["data"]
+            status = task_data.get("status", "unknown")
+            
+            # Update task status
+            tasks_db[task_id]["status"] = status
+            tasks_db[task_id]["last_checked"] = datetime.now().isoformat()
+            
+            if status == "completed" and "data" in task_data:
+                # Task completed successfully
+                lyrics_data = task_data["data"]
+                tasks_db[task_id]["result"] = lyrics_data
+                
+                # Format the output
+                return format_lyrics_output(lyrics_data, task_id)
+            
+            elif status == "failed":
+                error_msg = task_data.get("error", "Unknown error")
+                tasks_db[task_id]["error"] = error_msg
+                return f"""❌ **Task Failed**
 
 **Task ID:** `{task_id}`
-**Status:** {status}
-**Error:** {task.get('error', 'Unknown error')}
-**Method:** {method}
-**Elapsed:** {elapsed} seconds
+**Error:** {error_msg}
 
-💡 Please try generating again."""
-        else:
-            return f"📊 **Task Completed with status:** {status}"
-    
-    else:
-        # Task still in progress
-        status_icon = {
-            "created": "🆕",
-            "submitted": "⏳",
-            "processing": "🔄",
-            "pending": "⏱️"
-        }.get(status, "❓")
-        
-        return f"""{status_icon} **Task In Progress**
+💡 Please try generating again with a different prompt."""
+            
+            else:
+                # Still processing
+                elapsed = time_since(task["created_at"])
+                return f"""⏳ **Task Processing...**
 
 **Task ID:** `{task_id}`
 **Status:** {status}
-**Method:** {method}
-**Elapsed:** {elapsed} seconds
-**Last checked:** {task.get('last_checked', 'Never')}
+**Elapsed:** {elapsed}
 
-⏳ **Processing...** Please check back in a few seconds.
+⏰ **Estimated time:** 10-30 seconds
+🔄 **Auto-refresh recommended**
 
-🔁 **Auto-refreshing in 5 seconds...**"""
+💡 Check back in a few seconds!"""
+        
+        else:
+            error_msg = data.get("msg", f"HTTP {response.status_code}")
+            return f"❌ Error checking status: {error_msg}"
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def format_lyrics_result(lyrics_data, task_id, method):
-    """Format lyrics for display"""
+def format_lyrics_output(lyrics_data, task_id):
+    """Format the lyrics for display"""
     if not lyrics_data:
         return "✅ Task completed but no lyrics data received"
     
-    output = [f"🎵 **Generated Lyrics (Task: {task_id})**", ""]
+    output_lines = [
+        f"# 🎵 Generated Lyrics (Task: {task_id})",
+        "",
+        f"**Generated at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        ""
+    ]
     
     for i, item in enumerate(lyrics_data, 1):
         title = item.get('title', f'Variant {i}')
-        text = item.get('text', 'No lyrics generated')
+        lyrics = item.get('text', 'No lyrics generated')
         
-        output.append(f"### Variant {i}: {title}")
-        output.append("```")
-        output.append(text)
-        output.append("```")
-        output.append("---")
+        output_lines.append(f"## Variant {i}: {title}")
+        output_lines.append("```")
+        output_lines.append(lyrics)
+        output_lines.append("```")
+        output_lines.append("---")
+        output_lines.append("")
     
-    output.append(f"\n✅ **Completed via:** {method}")
-    output.append(f"🕒 **Finished at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    output_lines.append("### 🎉 All done!")
+    output_lines.append("You can generate more lyrics or try different prompts.")
     
-    return "\n".join(output)
+    return "\n".join(output_lines)
+
+def time_since(iso_timestamp: str) -> str:
+    """Calculate time elapsed since timestamp"""
+    try:
+        created = datetime.fromisoformat(iso_timestamp)
+        elapsed = datetime.now() - created
+        seconds = int(elapsed.total_seconds())
+        
+        if seconds < 60:
+            return f"{seconds} seconds"
+        elif seconds < 3600:
+            minutes = seconds // 60
+            return f"{minutes} minutes"
+        else:
+            hours = seconds // 3600
+            return f"{hours} hours"
+    except:
+        return "Unknown"
 
 def list_all_tasks():
-    """List all tasks with status"""
-    tasks = task_manager.get_all_tasks()
-    if not tasks:
+    """List all submitted tasks"""
+    if not tasks_db:
         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_lines = ["# 📋 All Submitted Tasks", ""]
     
-    output = ["📋 **All Tasks**", ""]
-    
-    for task in tasks:
+    for task_id, task in tasks_db.items():
+        status = task.get("status", "unknown")
+        prompt_preview = task.get("prompt", "")[:50]
+        created = task.get("created_at", "")[:19]
+        
         # Status icon
-        if task["completed"]:
-            icon = "✅" if task["status"] == "completed" else "❌"
+        if status == "completed":
+            icon = "✅"
+        elif status in ["failed", "error"]:
+            icon = "❌"
         else:
             icon = "⏳"
         
-        elapsed = (datetime.now() - task["created_at"]).seconds
-        method = task.get("method", "unknown")
+        output_lines.append(f"{icon} **{task_id}** - {status}")
+        output_lines.append(f"   Prompt: {prompt_preview}...")
+        output_lines.append(f"   Created: {created}")
         
-        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("last_checked"):
+            last_checked = task["last_checked"][:19]
+            output_lines.append(f"   Last checked: {last_checked}")
         
-        if task.get("error"):
-            output.append(f"   Error: {task['error'][:50]}...")
-        
-        output.append("")
+        output_lines.append("")
     
-    # Cleanup old tasks periodically
-    cleaned = task_manager.cleanup_old_tasks(hours=1)
-    if cleaned:
-        output.append(f"🧹 Cleaned up {cleaned} old tasks")
+    # Add summary
+    completed = sum(1 for t in tasks_db.values() if t.get("status") == "completed")
+    total = len(tasks_db)
+    output_lines.append(f"**Summary:** {completed}/{total} tasks completed")
     
-    return "\n".join(output)
+    return "\n".join(output_lines)
 
-# Webhook handler function for Gradio 6.0+
-async def webhook_handler(request: Request):
-    """Handle incoming webhook from Suno"""
-    try:
-        # Get the raw request body
-        body = await request.body()
-        print(f"📥 Webhook received: {request.method}")
-        
-        # Try to parse JSON
-        try:
-            data = json.loads(body.decode('utf-8'))
-        except:
-            # Try form data
-            form_data = await request.form()
-            data = dict(form_data) if form_data else {}
-        
-        print(f"📦 Webhook data received")
-        
-        # Extract task info (adjust based on Suno's actual format)
-        if isinstance(data, dict):
-            print(f"Data structure: {json.dumps(data, indent=2)[:500]}...")
-            
-            # 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"}
+def auto_refresh_status(task_id: str):
+    """Auto-refresh status with loading animation"""
+    if not task_id or task_id not in tasks_db:
+        return task_id, "❌ Invalid Task ID"
     
-    except Exception as e:
-        print(f"❌ Webhook error: {str(e)}")
-        return {"status": "error", "message": str(e)}
+    result = check_task_status(task_id)
+    return task_id, result
 
-# Create Gradio app
-with gr.Blocks() as app:
+# Create the Gradio interface
+with gr.Blocks(title="Suno Lyrics Generator", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🎵 Suno AI Lyrics Generator")
-    gr.Markdown("Hybrid solution: Webhooks with automatic polling fallback")
+    gr.Markdown("Generate song lyrics using Suno's AI API")
     
     with gr.Tabs():
+        # Tab 1: Generate Lyrics
         with gr.TabItem("✨ Generate"):
             with gr.Row():
                 with gr.Column(scale=2):
+                    gr.Markdown("### Enter your lyrics idea")
                     prompt_input = gr.Textbox(
                         label="Lyrics Prompt",
-                        placeholder="A jazz song about rainy nights in Tokyo...",
+                        placeholder="Example: A romantic ballad about stargazing on a summer night...",
                         lines=4
                     )
                     
-                    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", size="lg")
                     
-                    submit_btn = gr.Button("🚀 Generate Lyrics", variant="primary", scale=1)
-                    
-                    gr.Markdown("### 📋 Instructions:")
+                    gr.Markdown("### 📝 Tips:")
                     gr.Markdown("""
-                    1. Enter your lyrics idea
-                    2. Submit (webhooks enabled by default)
-                    3. Save your Task ID
-                    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
+                    • Be descriptive in your prompt
+                    • Include genre, mood, or theme
+                    • Specify if you want verses, chorus, bridge
+                    • Typical processing time: 10-30 seconds
                     """)
                 
                 with gr.Column(scale=3):
-                    output_result = gr.Markdown(
-                        label="Submission Result",
-                        value="Your results will appear here..."
+                    output_area = gr.Markdown(
+                        label="Result",
+                        value="Your task submission result will appear here..."
                     )
             
             submit_btn.click(
-                generate_lyrics,
-                inputs=[prompt_input, use_webhook],
-                outputs=output_result
+                fn=generate_lyrics,
+                inputs=prompt_input,
+                outputs=output_area
             )
         
+        # Tab 2: Check Status
         with gr.TabItem("🔍 Check Status"):
             with gr.Row():
                 with gr.Column():
+                    gr.Markdown("### Enter your Task ID")
                     task_id_input = gr.Textbox(
                         label="Task ID",
-                        placeholder="Enter your Task ID (e.g., a1b2c3d4)"
+                        placeholder="Paste your Task ID here (e.g., a1b2c3d4)",
+                        scale=1
                     )
                     
                     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")
+                        check_btn = gr.Button("🔍 Check Status", variant="primary")
+                        auto_refresh_btn = gr.Button("🔄 Auto-refresh", variant="secondary")
                     
-                    task_list_output = gr.Textbox(
-                        label="All Tasks",
-                        lines=10,
-                        interactive=False
-                    )
+                    gr.Markdown("---")
+                    refresh_all_btn = gr.Button("📋 List All Tasks")
+                    tasks_list = gr.Markdown(label="All Tasks")
                 
                 with gr.Column():
                     status_output = gr.Markdown(
-                        label="Task Status",
-                        value="Enter a Task ID and click Check Status"
+                        label="Status",
+                        value="Enter a Task ID above and click Check Status"
                     )
             
-            # Event handlers
+            # Connect buttons to functions
             check_btn.click(
-                check_task_status,
+                fn=check_task_status,
                 inputs=task_id_input,
                 outputs=status_output
             )
             
-            refresh_btn.click(
-                check_task_status,
+            auto_refresh_btn.click(
+                fn=auto_refresh_status,
                 inputs=task_id_input,
-                outputs=status_output
+                outputs=[task_id_input, status_output]
+            ).then(
+                fn=lambda: time.sleep(3),
+                inputs=None,
+                outputs=None
+            ).then(
+                fn=auto_refresh_status,
+                inputs=task_id_input,
+                outputs=[task_id_input, status_output]
             )
             
-            list_all_btn.click(
-                list_all_tasks,
+            refresh_all_btn.click(
+                fn=list_all_tasks,
                 inputs=None,
-                outputs=task_list_output
+                outputs=tasks_list
             )
         
-        with gr.TabItem("⚙️ Settings & Info"):
-            gr.Markdown("### ⚙️ Configuration")
+        # Tab 3: Help & Info
+        with gr.TabItem("ℹ️ Help"):
+            gr.Markdown("# Help & Information")
             
             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("### 🔑 API Status")
+                    api_status = "✅ Configured" if SUNO_KEY else "❌ Not configured"
+                    gr.Markdown(f"**SunoKey:** {api_status}")
                     
-                    gr.Markdown(f"**🌐 Space URL:** `{SPACE_URL}`")
-                    
-                    gr.Markdown("**🔄 Webhook Endpoint:**")
-                    webhook_info = gr.Textbox(
-                        value=f"{SPACE_URL}/callback",
-                        interactive=False
-                    )
+                    gr.Markdown("### 📋 How to Use:")
+                    gr.Markdown("""
+                    1. **Generate Tab:** Enter a lyrics prompt and submit
+                    2. **Save your Task ID** from the result
+                    3. **Check Status Tab:** Paste your Task ID to check progress
+                    4. **Results:** Lyrics will appear when processing is complete
+                    """)
                 
                 with gr.Column():
-                    gr.Markdown("**📊 Statistics:**")
-                    stats_text = gr.Textbox(
-                        value=f"Active tasks: {len(task_manager.get_all_tasks())}",
-                        interactive=False
-                    )
+                    gr.Markdown("### 🚨 Troubleshooting")
+                    gr.Markdown("""
+                    **Common Issues:**
                     
-                    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"""
-            **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
+                    • **"SunoKey not set":** Add your API key in Space Settings → Repository secrets
+                    • **"Task ID not found":** Submit a new task and save the ID
+                    • **Long processing time:** Suno API can take 10-30 seconds
+                    • **API errors:** Check if your API key is valid and has credits
+                    
+                    **For best results:**
+                    - Use descriptive prompts
+                    - Check status after 15-20 seconds
+                    - Save your Task IDs
+                    """)
             
-            **Your Webhook URL:** `{SPACE_URL}/callback`
+            gr.Markdown("### 📞 Support")
+            gr.Markdown("""
+            If you continue to have issues:
             
-            **Error Recovery:**
-            • Network issues → automatic retry
-            • API errors → informative messages
-            • Timeouts → fallback to polling
-            • All errors → logged for debugging
+            1. **Check your SunoKey** is correct and has available credits
+            2. **Try a simpler prompt** to test the API
+            3. **Wait a few minutes** if the API seems busy
+            4. **Contact Suno API support** for API-specific issues
             """)
-            
-            cleanup_btn.click(
-                lambda: f"Cleaned {task_manager.cleanup_old_tasks(hours=1)} old tasks",
-                inputs=None,
-                outputs=cleanup_output
-            )
-
-# 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__":
+    print(f"🔑 SunoKey status: {'Configured' if SUNO_KEY else 'NOT SET'}")
+    print(f"📊 Tasks in memory: {len(tasks_db)}")
     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,
         debug=False,
-        title="Suno Lyrics Generator",
-        theme="soft"
+        show_error=True
     )