Update app.py

app.py

@@ -1,1212 +1,157 @@
-"""
-HuggingChat MCP Importer - Gradio 6.0.2 MCP Server
-===================================================
-A comprehensive MCP server built with Gradio SDK 6.0.2 for bulk importing
-MCP server URLs from .txt files into HuggingChat.
-
-Features:
-- Parse MCP URLs from various file formats
-- Validate MCP server endpoints
-- Generate HuggingChat-compatible configurations
-- Health check MCP servers
-- List popular MCP servers
-
-MCP Endpoint: /gradio_api/mcp/
-Transport: Streamable HTTP (Gradio 6.0+)
-
-Author: DarkDriftz
-Version: 2.0.0
-"""
-
 import gradio as gr
-import httpx
-import json
-import asyncio
-import re
-import ssl
-from datetime import datetime
-from typing import Optional
-from urllib.parse import urlparse
-from concurrent.futures import ThreadPoolExecutor
-
-# ============================================================================
-# CONFIGURATION
-# ============================================================================
-
-APP_TITLE = "🔗 HuggingChat MCP Importer"
-APP_DESCRIPTION = """
-### Bulk Import MCP Servers to HuggingChat
-
-This tool helps you parse, validate, and configure MCP server URLs for use with HuggingChat.
-
-**Supported File Formats:**
-- Plain URLs (one per line)
-- `Name: URL` format
-- `Name|URL` format  
-- JSON arrays with optional headers
-- Comments with `#` or `//`
-
-**MCP Server Endpoint:** `/gradio_api/mcp/`
-"""
-
-# Popular MCP servers database
-POPULAR_MCP_SERVERS = {
-    "Official": [
-        {"name": "Hugging Face", "url": "https://huggingface.co/mcp", "description": "Official HuggingFace MCP server"},
-        {"name": "Anthropic MCP", "url": "https://mcp.anthropic.com", "description": "Anthropic's official MCP endpoint"},
-    ],
-    "Search & Research": [
-        {"name": "Exa Search", "url": "https://mcp.exa.ai/mcp", "description": "AI-powered search engine"},
-        {"name": "Tavily", "url": "https://mcp.tavily.com/mcp", "description": "Research and search API"},
-        {"name": "Brave Search", "url": "https://mcp.brave.com/mcp", "description": "Privacy-focused search"},
-    ],
-    "Development": [
-        {"name": "GitHub", "url": "https://mcp.github.com/mcp", "description": "GitHub integration"},
-        {"name": "GitLab", "url": "https://mcp.gitlab.com/mcp", "description": "GitLab integration"},
-        {"name": "Linear", "url": "https://mcp.linear.app/mcp", "description": "Project management"},
-    ],
-    "Productivity": [
-        {"name": "Notion", "url": "https://mcp.notion.so/mcp", "description": "Notion workspace integration"},
-        {"name": "Slack", "url": "https://mcp.slack.com/mcp", "description": "Slack messaging"},
-        {"name": "Google Drive", "url": "https://mcp.google.com/drive/mcp", "description": "Google Drive access"},
-    ],
-    "AI & ML": [
-        {"name": "Replicate", "url": "https://mcp.replicate.com/mcp", "description": "ML model hosting"},
-        {"name": "OpenAI", "url": "https://mcp.openai.com/mcp", "description": "OpenAI integration"},
-        {"name": "Stability AI", "url": "https://mcp.stability.ai/mcp", "description": "Image generation"},
-    ],
-    "Data & Analytics": [
-        {"name": "Snowflake", "url": "https://mcp.snowflake.com/mcp", "description": "Data warehouse"},
-        {"name": "BigQuery", "url": "https://mcp.google.com/bigquery/mcp", "description": "Google BigQuery"},
-        {"name": "PostgreSQL", "url": "https://mcp.postgresql.org/mcp", "description": "PostgreSQL database"},
-    ],
-}
-
-# ============================================================================
-# HELPER FUNCTIONS
-# ============================================================================
-
-def extract_name_from_url(url: str) -> str:
-    """Extract a readable name from URL."""
-    try:
-        parsed = urlparse(url)
-        hostname = parsed.hostname or ""
-        path = parsed.path.strip("/")
-        
-        # Try to get name from path first
-        if path and path != "mcp":
-            path_parts = [p for p in path.split("/") if p and p != "mcp"]
-            if path_parts:
-                name = path_parts[0]
-                name = re.sub(r'[-_]', ' ', name)
-                return name.title()
-        
-        # Fall back to hostname
-        if hostname:
-            parts = hostname.replace("mcp.", "").replace(".mcp", "").split(".")
-            if parts:
-                name = parts[0]
-                if name in ["www", "api"]:
-                    name = parts[1] if len(parts) > 1 else name
-                return name.title()
-        
-        return "Unknown Server"
-    except Exception:
-        return "Unknown Server"
-
-
-def parse_txt_content(content: str) -> list:
-    """Parse MCP URLs from text content supporting multiple formats."""
-    servers = []
-    lines = content.strip().split("\n")
-    
-    # Check if content is JSON
-    stripped = content.strip()
-    if stripped.startswith("[") or stripped.startswith("{"):
-        try:
-            data = json.loads(stripped)
-            if isinstance(data, list):
-                for item in data:
-                    if isinstance(item, str):
-                        servers.append({"name": extract_name_from_url(item), "url": item})
-                    elif isinstance(item, dict) and "url" in item:
-                        servers.append({
-                            "name": item.get("name", extract_name_from_url(item["url"])),
-                            "url": item["url"],
-                            "headers": item.get("headers", {})
-                        })
-                return servers
-            elif isinstance(data, dict) and "servers" in data:
-                return parse_txt_content(json.dumps(data["servers"]))
-        except json.JSONDecodeError:
-            pass
-    
-    # Parse line by line
-    for line in lines:
-        line = line.strip()
-        
-        # Skip empty lines and comments
-        if not line or line.startswith("#") or line.startswith("//"):
-            continue
-        
-        # Format: Name: URL
-        if ": " in line and not line.startswith("http"):
-            parts = line.split(": ", 1)
-            if len(parts) == 2 and parts[1].startswith("http"):
-                servers.append({"name": parts[0].strip(), "url": parts[1].strip()})
-                continue
-        
-        # Format: Name|URL
-        if "|" in line:
-            parts = line.split("|", 1)
-            if len(parts) == 2:
-                if parts[0].startswith("http"):
-                    servers.append({"name": parts[1].strip(), "url": parts[0].strip()})
-                else:
-                    servers.append({"name": parts[0].strip(), "url": parts[1].strip()})
-                continue
-        
-        # Plain URL
-        if line.startswith("http://") or line.startswith("https://"):
-            servers.append({"name": extract_name_from_url(line), "url": line})
-    
-    return servers
-
-
-async def validate_single_endpoint(url: str, timeout: float = 10.0) -> dict:
-    """Validate a single MCP endpoint."""
-    result = {
-        "url": url,
-        "valid": False,
-        "status_code": None,
-        "response_time_ms": None,
-        "has_tools": False,
-        "tool_count": 0,
-        "error": None
-    }
-    
+import torch
+import uuid
+import spaces
+from supermariogpt.dataset import MarioDataset
+from supermariogpt.prompter import Prompter
+from supermariogpt.lm import MarioLM
+from supermariogpt.utils import view_level, convert_level_to_png
+
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+
+import os
+import uvicorn
+from pathlib import Path
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize model
+try:
+    mario_lm = MarioLM()
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    mario_lm = mario_lm.to(device)
+    logger.info(f"Model loaded successfully on {device}")
+except Exception as e:
+    logger.error(f"Failed to load model: {e}")
+    raise
+
+TILE_DIR = "data/tiles"
+
+# Ensure static directory exists
+Path("static").mkdir(exist_ok=True)
+
+gr.set_static_paths(paths=[Path("static").absolute()])
+
+app = FastAPI()
+
+def make_html_file(generated_level):
+    """Generate HTML file for level visualization"""
     try:
-        start_time = datetime.now()
-        
-        async with httpx.AsyncClient(timeout=timeout, verify=True) as client:
-            # Try MCP discovery endpoint
-            response = await client.get(url)
-            
-            result["status_code"] = response.status_code
-            result["response_time_ms"] = int((datetime.now() - start_time).total_seconds() * 1000)
-            
-            if response.status_code == 200:
-                result["valid"] = True
-                
-                # Try to detect tools
-                try:
-                    data = response.json()
-                    if isinstance(data, dict):
-                        if "tools" in data:
-                            result["has_tools"] = True
-                            result["tool_count"] = len(data["tools"])
-                        elif "capabilities" in data:
-                            result["has_tools"] = True
-                except Exception:
-                    pass
-            else:
-                result["error"] = f"HTTP {response.status_code}"
-                
-    except httpx.TimeoutException:
-        result["error"] = "Connection timeout"
-    except httpx.ConnectError:
-        result["error"] = "Connection failed"
-    except ssl.SSLError as e:
-        result["error"] = f"SSL error: {str(e)[:50]}"
+        level_text = f"""{'''
+'''.join(view_level(generated_level, mario_lm.tokenizer))}"""
+        unique_id = uuid.uuid4()  # Changed from uuid1 to uuid4 for better randomness
+        html_filename = f"demo-{unique_id}.html"
+        
+        html_content = f'''<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <title>supermariogpt</title>
+    <script src="https://cjrtnc.leaningtech.com/20230216/loader.js"></script>
+</head>
+
+<body>
+</body>
+<script>
+    cheerpjInit().then(function () {{
+        cheerpjAddStringFile("/str/mylevel.txt", `{level_text}`);
+    }});
+    cheerpjCreateDisplay(512, 500);
+    cheerpjRunJar("/app/gradio_api/file=static/mario.jar");
+</script>
+</html>'''
+        
+        with open(Path("static") / html_filename, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        return html_filename
     except Exception as e:
-        result["error"] = str(e)[:100]
-    
-    return result
-
+        logger.error(f"Error creating HTML file: {e}")
+        raise
 
-def run_async(coro):
-    """Run async coroutine in sync context."""
+@spaces.GPU
+def generate(pipes, enemies, blocks, elevation, temperature=2.0, level_size=1399, prompt="", progress=gr.Progress(track_tqdm=True)):
+    """Generate Mario level based on parameters"""
     try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    return loop.run_until_complete(coro)
-
-
-# ============================================================================
-# TOOL FUNCTIONS (These become MCP tools)
-# ============================================================================
-
-def parse_mcp_urls(
-    file_content: str,
-    output_format: str = "markdown"
-) -> str:
-    """
-    Parse MCP server URLs from text content.
-    
-    Supports multiple formats:
-    - Plain URLs (one per line)
-    - Name: URL format
-    - Name|URL format
-    - JSON arrays
-    - Comments with # or //
-    
-    Args:
-        file_content: Text content containing MCP server URLs
-        output_format: Output format - 'markdown' or 'json'
-    
-    Returns:
-        Parsed servers in the requested format
-    """
-    if not file_content or not file_content.strip():
-        return "❌ Error: No content provided. Please paste your MCP server URLs."
-    
-    servers = parse_txt_content(file_content)
-    
-    if not servers:
-        return "❌ No valid MCP server URLs found in the content."
-    
-    if output_format == "json":
-        return json.dumps(servers, indent=2)
-    
-    # Markdown output
-    lines = [
-        f"# 📋 Parsed MCP Servers",
-        f"",
-        f"**Found {len(servers)} server(s)**",
-        f"",
-        "| # | Name | URL |",
-        "|---|------|-----|"
-    ]
-    
-    for i, server in enumerate(servers, 1):
-        name = server.get("name", "Unknown")
-        url = server.get("url", "")
-        lines.append(f"| {i} | {name} | `{url}` |")
-    
-    lines.extend([
-        "",
-        "---",
-        "*Use 'Validate Servers' to check connectivity*"
-    ])
-    
-    return "\n".join(lines)
-
-
-def validate_mcp_servers(
-    urls_text: str,
-    timeout_seconds: float = 10.0
-) -> str:
-    """
-    Validate MCP server endpoints for connectivity and availability.
-    
-    Checks each URL for:
-    - HTTP connectivity
-    - Response time
-    - Tool availability
-    - SSL certificate validity
-    
-    Args:
-        urls_text: Newline-separated list of MCP server URLs or parsed content
-        timeout_seconds: Request timeout in seconds (default: 10)
-    
-    Returns:
-        Validation results in markdown format
-    """
-    if not urls_text or not urls_text.strip():
-        return "❌ Error: No URLs provided for validation."
-    
-    # Parse URLs
-    servers = parse_txt_content(urls_text)
-    if not servers:
-        # Try treating as simple URL list
-        urls = [u.strip() for u in urls_text.strip().split("\n") if u.strip().startswith("http")]
-        servers = [{"name": extract_name_from_url(u), "url": u} for u in urls]
-    
-    if not servers:
-        return "❌ No valid URLs found to validate."
-    
-    # Validate each server
-    async def validate_all():
-        tasks = [validate_single_endpoint(s["url"], timeout_seconds) for s in servers]
-        return await asyncio.gather(*tasks)
-    
-    results = run_async(validate_all())
-    
-    # Build report
-    valid_count = sum(1 for r in results if r["valid"])
-    
-    lines = [
-        "# ✅ MCP Server Validation Results",
-        "",
-        f"**Validated: {valid_count}/{len(results)} servers online**",
-        "",
-        "| Status | Name | URL | Response Time | Tools |",
-        "|--------|------|-----|---------------|-------|"
-    ]
-    
-    for server, result in zip(servers, results):
-        status = "✅" if result["valid"] else "❌"
-        name = server.get("name", "Unknown")
-        url = server.get("url", "")[:50] + "..." if len(server.get("url", "")) > 50 else server.get("url", "")
-        
-        if result["response_time_ms"]:
-            response_time = f"{result['response_time_ms']}ms"
-        else:
-            response_time = result.get("error", "N/A")[:30]
-        
-        tools = f"{result['tool_count']}" if result["has_tools"] else "-"
-        
-        lines.append(f"| {status} | {name} | `{url}` | {response_time} | {tools} |")
-    
-    # Summary
-    lines.extend([
-        "",
-        "## Summary",
-        f"- ✅ Online: {valid_count}",
-        f"- ❌ Offline: {len(results) - valid_count}",
-        f"- ⏱️ Avg Response: {sum(r['response_time_ms'] or 0 for r in results) // max(valid_count, 1)}ms"
-    ])
-    
-    return "\n".join(lines)
-
-
-def generate_huggingchat_config(
-    urls_text: str,
-    include_headers: bool = False
-) -> str:
-    """
-    Generate HuggingChat-compatible MCP configuration JSON.
-    
-    Creates a JSON configuration that can be used with HuggingChat's
-    MCP server settings or the MCP_SERVERS environment variable.
-    
-    Args:
-        urls_text: Text content containing MCP server URLs
-        include_headers: Include empty headers object for each server
-    
-    Returns:
-        JSON configuration for HuggingChat
-    """
-    if not urls_text or not urls_text.strip():
-        return "❌ Error: No URLs provided."
-    
-    servers = parse_txt_content(urls_text)
-    
-    if not servers:
-        return "❌ No valid MCP server URLs found."
-    
-    # Build HuggingChat config
-    config = {"mcpServers": {}}
-    
-    for server in servers:
-        name = server.get("name", "unknown").lower().replace(" ", "-")
-        # Ensure unique names
-        base_name = name
-        counter = 1
-        while name in config["mcpServers"]:
-            name = f"{base_name}-{counter}"
-            counter += 1
-        
-        server_config = {"url": server.get("url", "")}
-        
-        if include_headers:
-            server_config["headers"] = server.get("headers", {})
-        
-        config["mcpServers"][name] = server_config
-    
-    output = [
-        "# 🔧 HuggingChat MCP Configuration",
-        "",
-        "## JSON Configuration",
-        "```json",
-        json.dumps(config, indent=2),
-        "```",
-        "",
-        "## Environment Variable Format",
-        "```bash",
-        f'export MCP_SERVERS=\'{json.dumps(config["mcpServers"])}\'',
-        "```",
-        "",
-        "## Instructions",
-        "1. Go to https://huggingface.co/settings/mcp",
-        "2. Add each server using the URLs above",
-        "3. Or use the environment variable for self-hosted instances",
-        "",
-        f"**Total Servers: {len(servers)}**"
-    ]
-    
-    return "\n".join(output)
-
-
-def health_check_servers(
-    urls_text: str,
-    check_ssl: bool = True,
-    detailed: bool = False
-) -> str:
-    """
-    Perform comprehensive health checks on MCP servers.
-    
-    Checks include:
-    - HTTP/HTTPS connectivity
-    - SSL certificate validation
-    - Response time measurement
-    - Endpoint availability
-    
-    Args:
-        urls_text: Text content containing MCP server URLs
-        check_ssl: Verify SSL certificates (default: True)
-        detailed: Include detailed error information
-    
-    Returns:
-        Health check report in markdown format
-    """
-    if not urls_text or not urls_text.strip():
-        return "❌ Error: No URLs provided for health check."
-    
-    servers = parse_txt_content(urls_text)
-    if not servers:
-        urls = [u.strip() for u in urls_text.strip().split("\n") if u.strip().startswith("http")]
-        servers = [{"name": extract_name_from_url(u), "url": u} for u in urls]
-    
-    if not servers:
-        return "❌ No valid URLs found."
-    
-    async def check_health(url: str) -> dict:
-        result = {
-            "url": url,
-            "status": "unknown",
-            "http_ok": False,
-            "ssl_ok": None,
-            "response_time_ms": None,
-            "error": None
-        }
-        
-        try:
-            start = datetime.now()
-            async with httpx.AsyncClient(timeout=15.0, verify=check_ssl) as client:
-                response = await client.get(url)
-                result["response_time_ms"] = int((datetime.now() - start).total_seconds() * 1000)
-                result["http_ok"] = response.status_code < 400
-                result["ssl_ok"] = url.startswith("https://")
-                result["status"] = "healthy" if result["http_ok"] else "unhealthy"
-        except ssl.SSLError as e:
-            result["status"] = "ssl_error"
-            result["ssl_ok"] = False
-            result["error"] = str(e)[:100] if detailed else "SSL certificate error"
-        except Exception as e:
-            result["status"] = "error"
-            result["error"] = str(e)[:100] if detailed else "Connection failed"
-        
-        return result
-    
-    async def check_all():
-        tasks = [check_health(s["url"]) for s in servers]
-        return await asyncio.gather(*tasks)
-    
-    results = run_async(check_all())
-    
-    healthy = sum(1 for r in results if r["status"] == "healthy")
-    
-    lines = [
-        "# 🏥 MCP Server Health Report",
-        "",
-        f"**Health Status: {healthy}/{len(results)} servers healthy**",
-        f"*Checked at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}*",
-        "",
-        "| Health | Server | SSL | Response | Details |",
-        "|--------|--------|-----|----------|---------|"
-    ]
-    
-    status_icons = {
-        "healthy": "🟢",
-        "unhealthy": "🟡",
-        "ssl_error": "🔴",
-        "error": "🔴",
-        "unknown": "⚪"
-    }
-    
-    for server, result in zip(servers, results):
-        icon = status_icons.get(result["status"], "⚪")
-        name = server.get("name", "Unknown")[:20]
-        ssl_status = "✅" if result["ssl_ok"] else ("❌" if result["ssl_ok"] is False else "-")
-        response = f"{result['response_time_ms']}ms" if result["response_time_ms"] else "-"
-        details = result.get("error", "OK")[:30] if result.get("error") else "OK"
-        
-        lines.append(f"| {icon} | {name} | {ssl_status} | {response} | {details} |")
-    
-    lines.extend([
-        "",
-        "## Legend",
-        "- 🟢 Healthy - Server responding normally",
-        "- 🟡 Unhealthy - Server returned error status",
-        "- 🔴 Error - Connection or SSL failure",
-    ])
-    
-    return "\n".join(lines)
-
-
-def list_popular_servers(
-    category: str = "All",
-    output_format: str = "markdown"
-) -> str:
-    """
-    List popular and recommended MCP servers.
-    
-    Provides a curated list of well-known MCP servers organized
-    by category for easy discovery.
-    
-    Args:
-        category: Filter by category (All, Official, Search, Development, etc.)
-        output_format: Output format - 'markdown' or 'json'
-    
-    Returns:
-        List of popular MCP servers
-    """
-    if category == "All":
-        all_servers = []
-        for cat, servers in POPULAR_MCP_SERVERS.items():
-            for s in servers:
-                all_servers.append({**s, "category": cat})
-        servers = all_servers
-    else:
-        servers = POPULAR_MCP_SERVERS.get(category, [])
-        servers = [{**s, "category": category} for s in servers]
-    
-    if not servers:
-        available = ", ".join(POPULAR_MCP_SERVERS.keys())
-        return f"❌ Category not found. Available: All, {available}"
-    
-    if output_format == "json":
-        return json.dumps(servers, indent=2)
-    
-    lines = [
-        "# 🌟 Popular MCP Servers",
-        "",
-        f"**Showing: {category}** ({len(servers)} servers)",
-        ""
-    ]
-    
-    if category == "All":
-        for cat in POPULAR_MCP_SERVERS.keys():
-            lines.append(f"## {cat}")
-            lines.append("")
-            lines.append("| Name | URL | Description |")
-            lines.append("|------|-----|-------------|")
-            for s in POPULAR_MCP_SERVERS[cat]:
-                lines.append(f"| {s['name']} | `{s['url']}` | {s['description']} |")
-            lines.append("")
-    else:
-        lines.append("| Name | URL | Description |")
-        lines.append("|------|-----|-------------|")
-        for s in servers:
-            lines.append(f"| {s['name']} | `{s['url']}` | {s['description']} |")
-    
-    lines.extend([
-        "",
-        "---",
-        "*Copy URLs and use 'Generate Config' to create HuggingChat configuration*"
-    ])
-    
-    return "\n".join(lines)
-
-
-def create_sample_file() -> str:
-    """
-    Create a sample MCP URLs file with various formats.
-    
-    Generates example content showing all supported URL formats
-    that can be used as a template.
-    
-    Returns:
-        Sample file content with examples
-    """
-    sample = """# Sample MCP Server URLs File
-# ============================
-# This file demonstrates all supported formats
-
-# Format 1: Plain URLs (one per line)
-https://huggingface.co/mcp
-https://mcp.exa.ai/mcp
-
-# Format 2: Name: URL
-Tavily Search: https://mcp.tavily.com/mcp
-Brave Search: https://mcp.brave.com/mcp
-
-# Format 3: Name|URL (pipe-separated)
-GitHub|https://mcp.github.com/mcp
-Linear|https://mcp.linear.app/mcp
-
-# Format 4: JSON array (paste this separately)
-# [
-#   {"name": "Custom Server", "url": "https://custom.example.com/mcp"},
-#   {"name": "API Server", "url": "https://api.example.com/mcp", "headers": {"Authorization": "Bearer token"}}
-# ]
-
-// Double-slash comments also work
-// Add your own servers below:
-
-"""
-    
-    output = [
-        "# 📄 Sample MCP URLs File",
-        "",
-        "Copy the content below and modify for your needs:",
-        "",
-        "```txt",
-        sample,
-        "```",
-        "",
-        "## Supported Formats",
-        "1. **Plain URL**: `https://example.com/mcp`",
-        "2. **Named**: `Server Name: https://example.com/mcp`",
-        "3. **Pipe-separated**: `Server Name|https://example.com/mcp`",
-        "4. **JSON**: `[{\"name\": \"...\", \"url\": \"...\"}]`",
-        "",
-        "## Tips",
-        "- Use `#` or `//` for comments",
-        "- Names are auto-extracted if not provided",
-        "- JSON format supports custom headers"
-    ]
-    
-    return "\n".join(output)
-
-
-def convert_to_claude_desktop_config(
-    urls_text: str
-) -> str:
-    """
-    Convert MCP URLs to Claude Desktop configuration format.
-    
-    Generates JSON configuration compatible with Claude Desktop's
-    MCP server settings.
-    
-    Args:
-        urls_text: Text content containing MCP server URLs
-    
-    Returns:
-        Claude Desktop compatible JSON configuration
-    """
-    if not urls_text or not urls_text.strip():
-        return "❌ Error: No URLs provided."
-    
-    servers = parse_txt_content(urls_text)
-    
-    if not servers:
-        return "❌ No valid MCP server URLs found."
-    
-    # Claude Desktop uses streamable HTTP format
-    config = {"mcpServers": {}}
-    
-    for server in servers:
-        name = server.get("name", "unknown").lower().replace(" ", "-")
-        name = re.sub(r'[^a-z0-9-]', '', name)
-        
-        base_name = name
-        counter = 1
-        while name in config["mcpServers"]:
-            name = f"{base_name}-{counter}"
-            counter += 1
-        
-        # Claude Desktop format for remote MCP servers
-        config["mcpServers"][name] = {
-            "command": "npx",
-            "args": ["mcp-remote", server.get("url", "")]
-        }
-    
-    output = [
-        "# 🖥️ Claude Desktop MCP Configuration",
-        "",
-        "Add this to your Claude Desktop config file:",
-        "- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`",
-        "- **Windows**: `%APPDATA%\\Claude\\claude_desktop_config.json`",
-        "",
-        "```json",
-        json.dumps(config, indent=2),
-        "```",
-        "",
-        "## Requirements",
-        "- Node.js must be installed",
-        "- `npx` must be available in PATH",
-        "",
-        f"**Total Servers: {len(servers)}**"
-    ]
-    
-    return "\n".join(output)
-
-
-def detect_duplicate_servers(
-    imported_config: str,
-    new_servers_txt: str,
-    match_mode: str = "url"
-) -> str:
-    """
-    Detect duplicate MCP servers by comparing imported servers with a txt file.
-    
-    Compares your currently imported HuggingChat MCP servers against servers
-    in a txt file to identify duplicates, new servers, and existing-only servers.
-    
-    Args:
-        imported_config: Your current HuggingChat MCP config (JSON) or list of URLs
-        new_servers_txt: Text file content with MCP servers to compare
-        match_mode: How to match servers - 'url' (exact URL), 'domain' (same domain), or 'name' (by name)
-    
-    Returns:
-        Comparison report showing duplicates, new servers, and recommendations
-    """
-    if not imported_config or not imported_config.strip():
-        return "❌ Error: Please paste your current HuggingChat MCP configuration or list of imported server URLs."
-    
-    if not new_servers_txt or not new_servers_txt.strip():
-        return "❌ Error: Please provide the txt file content with servers to compare."
-    
-    # Parse the imported config
-    imported_servers = []
-    stripped_config = imported_config.strip()
-    
-    # Try parsing as JSON config first
-    if stripped_config.startswith("{") or stripped_config.startswith("["):
-        try:
-            data = json.loads(stripped_config)
-            
-            # Handle HuggingChat mcpServers format
-            if isinstance(data, dict):
-                if "mcpServers" in data:
-                    for name, config in data["mcpServers"].items():
-                        url = config.get("url", "") if isinstance(config, dict) else ""
-                        imported_servers.append({"name": name, "url": url})
-                elif all(isinstance(v, dict) for v in data.values()):
-                    # Direct server dict format
-                    for name, config in data.items():
-                        url = config.get("url", "") if isinstance(config, dict) else ""
-                        imported_servers.append({"name": name, "url": url})
-            elif isinstance(data, list):
-                for item in data:
-                    if isinstance(item, str):
-                        imported_servers.append({"name": extract_name_from_url(item), "url": item})
-                    elif isinstance(item, dict) and "url" in item:
-                        imported_servers.append({
-                            "name": item.get("name", extract_name_from_url(item["url"])),
-                            "url": item["url"]
-                        })
-        except json.JSONDecodeError:
-            pass
-    
-    # If JSON parsing didn't work, try line-by-line parsing
-    if not imported_servers:
-        imported_servers = parse_txt_content(imported_config)
-    
-    if not imported_servers:
-        return "❌ Could not parse your imported servers. Please paste either:\n- JSON config from HuggingChat\n- List of URLs (one per line)\n- Name: URL format"
-    
-    # Parse the new servers from txt file
-    new_servers = parse_txt_content(new_servers_txt)
-    
-    if not new_servers:
-        return "❌ Could not parse any servers from the txt file content."
-    
-    # Normalize URLs for comparison
-    def normalize_url(url: str) -> str:
-        """Normalize URL for comparison."""
-        url = url.lower().strip()
-        url = re.sub(r'^https?://', '', url)
-        url = re.sub(r'/$', '', url)
-        return url
-    
-    def get_domain(url: str) -> str:
-        """Extract domain from URL."""
-        try:
-            parsed = urlparse(url)
-            return (parsed.hostname or "").lower()
-        except:
-            return ""
-    
-    # Build lookup sets based on match mode
-    imported_urls = {normalize_url(s["url"]) for s in imported_servers if s.get("url")}
-    imported_domains = {get_domain(s["url"]) for s in imported_servers if s.get("url")}
-    imported_names = {s["name"].lower().strip() for s in imported_servers if s.get("name")}
-    
-    # Categorize new servers
-    duplicates = []
-    new_to_import = []
-    
-    for server in new_servers:
-        url = server.get("url", "")
-        name = server.get("name", "")
-        normalized = normalize_url(url)
-        domain = get_domain(url)
+        # Validate inputs
+        temperature = max(0.1, min(2.0, float(temperature)))
+        level_size = max(100, min(2799, int(level_size)))
+        
+        if prompt == "":
+            prompt = f"{pipes} pipes, {enemies} enemies, {blocks} blocks, {elevation} elevation"
+        
+        logger.info(f"Using prompt: {prompt}")
+        logger.info(f"Using temperature: {temperature}")
+        logger.info(f"Using level size: {level_size}")
+        
+        prompts = [prompt]
+        generated_level = mario_lm.sample(
+            prompts=prompts,
+            num_steps=level_size,
+            temperature=float(temperature),
+            use_tqdm=True
+        )
         
-        is_duplicate = False
-        match_reason = ""
+        filename = make_html_file(generated_level)
+        img = convert_level_to_png(generated_level.squeeze(), TILE_DIR, mario_lm.tokenizer)[0]
         
-        if match_mode == "url":
-            if normalized in imported_urls:
-                is_duplicate = True
-                match_reason = "exact URL match"
-        elif match_mode == "domain":
-            if domain and domain in imported_domains:
-                is_duplicate = True
-                match_reason = f"same domain ({domain})"
-        elif match_mode == "name":
-            if name.lower().strip() in imported_names:
-                is_duplicate = True
-                match_reason = "same name"
+        gradio_html = f'''<div>
+            <iframe width=512 height=512 style="margin: 0 auto" src="/gradio_api/file=static/{filename}"></iframe>
+            <p style="text-align:center">Press the arrow keys to move. Press <code>a</code> to run, <code>s</code> to jump and <code>d</code> to shoot fireflowers</p>
+        </div>'''
         
-        if is_duplicate:
-            duplicates.append({**server, "match_reason": match_reason})
-        else:
-            new_to_import.append(server)
-    
-    # Find servers in imported but not in new list
-    new_urls = {normalize_url(s["url"]) for s in new_servers if s.get("url")}
-    only_in_imported = [s for s in imported_servers if normalize_url(s.get("url", "")) not in new_urls]
-    
-    # Build report
-    lines = [
-        "# 🔍 Duplicate Detection Report",
-        "",
-        f"**Match Mode:** {match_mode.title()}",
-        f"**Imported Servers:** {len(imported_servers)}",
-        f"**Servers in TXT File:** {len(new_servers)}",
-        "",
-        "---",
-        ""
-    ]
-    
-    # Duplicates section
-    if duplicates:
-        lines.extend([
-            f"## ⚠️ Already Imported ({len(duplicates)})",
-            "",
-            "These servers are already in your HuggingChat and **don't need to be imported again**:",
-            "",
-            "| Server | URL | Match Reason |",
-            "|--------|-----|--------------|"
-        ])
-        for s in duplicates:
-            name = s.get("name", "Unknown")[:25]
-            url = s.get("url", "")[:40] + ("..." if len(s.get("url", "")) > 40 else "")
-            reason = s.get("match_reason", "")
-            lines.append(f"| {name} | `{url}` | {reason} |")
-        lines.append("")
-    else:
-        lines.extend([
-            "## ✅ No Duplicates Found",
-            "",
-            "None of the servers in the txt file are already imported.",
-            ""
-        ])
-    
-    # New servers section
-    if new_to_import:
-        lines.extend([
-            f"## 🆕 New Servers to Import ({len(new_to_import)})",
-            "",
-            "These servers are **not yet imported** and can be added:",
-            "",
-            "| Server | URL |",
-            "|--------|-----|"
-        ])
-        for s in new_to_import:
-            name = s.get("name", "Unknown")[:25]
-            url = s.get("url", "")[:50] + ("..." if len(s.get("url", "")) > 50 else "")
-            lines.append(f"| {name} | `{url}` |")
-        lines.append("")
-        
-        # Generate import config for new servers only
-        lines.extend([
-            "### Quick Import Config (New Servers Only)",
-            "",
-            "```json",
-            json.dumps({
-                "mcpServers": {
-                    s.get("name", "unknown").lower().replace(" ", "-"): {"url": s.get("url", "")}
-                    for s in new_to_import
-                }
-            }, indent=2),
-            "```",
-            ""
-        ])
-    else:
-        lines.extend([
-            "## ℹ️ No New Servers",
-            "",
-            "All servers in the txt file are already imported.",
-            ""
-        ])
-    
-    # Only in imported section
-    if only_in_imported:
-        lines.extend([
-            f"## 📋 Only in HuggingChat ({len(only_in_imported)})",
-            "",
-            "These servers are imported but **not in your txt file** (you may want to add them):",
-            "",
-            "| Server | URL |",
-            "|--------|-----|"
-        ])
-        for s in only_in_imported[:10]:  # Limit to 10
-            name = s.get("name", "Unknown")[:25]
-            url = s.get("url", "")[:50] + ("..." if len(s.get("url", "")) > 50 else "")
-            lines.append(f"| {name} | `{url}` |")
-        if len(only_in_imported) > 10:
-            lines.append(f"| ... | *and {len(only_in_imported) - 10} more* |")
-        lines.append("")
-    
-    # Summary
-    lines.extend([
-        "---",
-        "## 📊 Summary",
-        "",
-        f"- ⚠️ **Duplicates (skip):** {len(duplicates)}",
-        f"- 🆕 **New (import these):** {len(new_to_import)}",
-        f"- 📋 **Only in HuggingChat:** {len(only_in_imported)}",
-        "",
-        "*Use the 'Generate Config' tab with the new servers list to create an import configuration.*"
-    ])
-    
-    return "\n".join(lines)
-
-
-# ============================================================================
-# GRADIO INTERFACE DEFINITIONS
-# ============================================================================
-
-# Create individual interfaces for each tool
-parse_interface = gr.Interface(
-    fn=parse_mcp_urls,
-    inputs=[
-        gr.Textbox(
-            label="MCP URLs Content",
-            placeholder="Paste your MCP server URLs here...\n\nSupported formats:\n- https://example.com/mcp\n- Server Name: https://example.com/mcp\n- Server Name|https://example.com/mcp",
-            lines=10
-        ),
-        gr.Radio(
-            choices=["markdown", "json"],
-            value="markdown",
-            label="Output Format"
-        )
-    ],
-    outputs=gr.Markdown(label="Parsed Results"),
-    api_name="parse_mcp_urls",
-    title="📋 Parse MCP URLs",
-    description="Parse MCP server URLs from various text formats"
-)
-
-validate_interface = gr.Interface(
-    fn=validate_mcp_servers,
-    inputs=[
-        gr.Textbox(
-            label="MCP URLs to Validate",
-            placeholder="Paste URLs to validate (one per line or parsed format)",
-            lines=8
-        ),
-        gr.Slider(
-            minimum=5,
-            maximum=30,
-            value=10,
-            step=1,
-            label="Timeout (seconds)"
-        )
-    ],
-    outputs=gr.Markdown(label="Validation Results"),
-    api_name="validate_mcp_servers",
-    title="✅ Validate MCP Servers",
-    description="Check connectivity and availability of MCP endpoints"
-)
-
-generate_config_interface = gr.Interface(
-    fn=generate_huggingchat_config,
-    inputs=[
-        gr.Textbox(
-            label="MCP URLs",
-            placeholder="Paste MCP server URLs to generate config",
-            lines=8
-        ),
-        gr.Checkbox(
-            label="Include Headers Template",
-            value=False
-        )
-    ],
-    outputs=gr.Markdown(label="HuggingChat Configuration"),
-    api_name="generate_huggingchat_config",
-    title="🔧 Generate HuggingChat Config",
-    description="Create HuggingChat-compatible MCP configuration"
-)
-
-health_check_interface = gr.Interface(
-    fn=health_check_servers,
-    inputs=[
-        gr.Textbox(
-            label="MCP URLs",
-            placeholder="Paste URLs for health check",
-            lines=8
-        ),
-        gr.Checkbox(
-            label="Verify SSL Certificates",
-            value=True
-        ),
-        gr.Checkbox(
-            label="Show Detailed Errors",
-            value=False
-        )
-    ],
-    outputs=gr.Markdown(label="Health Report"),
-    api_name="health_check_mcp_servers",
-    title="🏥 Health Check",
-    description="Comprehensive health monitoring for MCP servers"
-)
-
-popular_servers_interface = gr.Interface(
-    fn=list_popular_servers,
-    inputs=[
-        gr.Dropdown(
-            choices=["All", "Official", "Search & Research", "Development", "Productivity", "AI & ML", "Data & Analytics"],
-            value="All",
-            label="Category"
-        ),
-        gr.Radio(
-            choices=["markdown", "json"],
-            value="markdown",
-            label="Output Format"
-        )
-    ],
-    outputs=gr.Markdown(label="Popular Servers"),
-    api_name="list_popular_mcp_servers",
-    title="🌟 Popular MCP Servers",
-    description="Discover curated MCP servers by category"
-)
-
-sample_file_interface = gr.Interface(
-    fn=create_sample_file,
-    inputs=[],
-    outputs=gr.Markdown(label="Sample File"),
-    api_name="create_sample_urls_file",
-    title="📄 Sample URLs File",
-    description="Generate a template file with example formats"
-)
-
-claude_config_interface = gr.Interface(
-    fn=convert_to_claude_desktop_config,
-    inputs=[
-        gr.Textbox(
-            label="MCP URLs",
-            placeholder="Paste MCP server URLs",
-            lines=8
-        )
-    ],
-    outputs=gr.Markdown(label="Claude Desktop Config"),
-    api_name="convert_to_claude_desktop",
-    title="🖥️ Claude Desktop Config",
-    description="Generate Claude Desktop MCP configuration"
-)
-
-duplicate_detection_interface = gr.Interface(
-    fn=detect_duplicate_servers,
-    inputs=[
-        gr.Textbox(
-            label="Your Imported Servers (from HuggingChat)",
-            placeholder='Paste your current HuggingChat MCP config here...\n\nAccepted formats:\n1. JSON config: {"mcpServers": {"server-name": {"url": "..."}}}\n2. URL list (one per line)\n3. Name: URL format\n\nYou can export this from HuggingChat settings or paste your server URLs.',
-            lines=10
-        ),
-        gr.Textbox(
-            label="Servers from TXT File (to compare)",
-            placeholder="Paste the content of your servers.txt file here...\n\nThese are the servers you want to check for duplicates.",
-            lines=10
-        ),
-        gr.Radio(
-            choices=["url", "domain", "name"],
-            value="url",
-            label="Match Mode",
-            info="URL: exact match | Domain: same domain | Name: same server name"
-        )
-    ],
-    outputs=gr.Markdown(label="Duplicate Detection Results"),
-    api_name="detect_duplicate_servers",
-    title="🔍 Detect Duplicates",
-    description="Compare your imported HuggingChat servers with a txt file to find duplicates"
-)
-
-# ============================================================================
-# MAIN APPLICATION
-# ============================================================================
-
-# Create tabbed interface combining all tools
-demo = gr.TabbedInterface(
-    interface_list=[
-        parse_interface,
-        validate_interface,
-        generate_config_interface,
-        duplicate_detection_interface,
-        health_check_interface,
-        popular_servers_interface,
-        sample_file_interface,
-        claude_config_interface
-    ],
-    tab_names=[
-        "📋 Parse",
-        "✅ Validate", 
-        "🔧 HuggingChat Config",
-        "🔍 Detect Duplicates",
-        "🏥 Health Check",
-        "🌟 Popular Servers",
-        "📄 Sample File",
-        "🖥️ Claude Desktop"
-    ],
-    title=APP_TITLE
-)
-
-# Add custom CSS and header
-with gr.Blocks(title=APP_TITLE) as app:
-    gr.Markdown(APP_DESCRIPTION)
-    
-    # Embed the tabbed interface
-    demo.render()
-    
-    gr.Markdown("""
-    ---
-    ### 🔗 MCP Server Information
-    
-    **MCP Endpoint:** `/gradio_api/mcp/`
-    
-    **For Claude Desktop / Cursor / Windsurf:**
-    ```json
-    {
-      "mcpServers": {
-        "huggingchat-importer": {
-          "url": "http://localhost:7860/gradio_api/mcp/"
-        }
-      }
-    }
-    ```
-    
-    **For clients without Streamable HTTP support:**
-    ```json
-    {
-      "mcpServers": {
-        "huggingchat-importer": {
-          "command": "npx",
-          "args": ["mcp-remote", "http://localhost:7860/gradio_api/mcp/"]
-        }
-      }
-    }
-    ```
-    
-    ---
-    *Built with Gradio 6.0.2 | MCP Transport: Streamable HTTP*
-    """)
-
-# ============================================================================
-# LAUNCH
-# ============================================================================
+        return [img, gradio_html]
+    except Exception as e:
+        logger.error(f"Error generating level: {e}")
+        raise gr.Error(f"Failed to generate level: {str(e)}")
+
+with gr.Blocks().queue() as demo:
+    gr.Markdown('''# MarioGPT
+### Playable demo for MarioGPT: Open-Ended Text2Level Generation through Large Language Models
+[[Github](https://github.com/shyamsn97/mario-gpt)], [[Paper](https://arxiv.org/abs/2302.05981)]
+    ''')
+    with gr.Tabs():
+        with gr.TabItem("Compose prompt"):
+            with gr.Row():
+                pipes = gr.Radio(["no", "little", "some", "many"], value="some", label="How many pipes?")
+                enemies = gr.Radio(["no", "little", "some", "many"], value="some", label="How many enemies?")
+            with gr.Row():
+                blocks = gr.Radio(["little", "some", "many"], value="some", label="How many blocks?")
+                elevation = gr.Radio(["low", "high"], value="low", label="Elevation?")
+        with gr.TabItem("Type prompt"):
+            text_prompt = gr.Textbox(value="", label="Enter your MarioGPT prompt. ex: 'many pipes, many enemies, some blocks, low elevation'")
+        
+    with gr.Accordion(label="Advanced settings", open=False):
+        temperature = gr.Slider(value=2.0, minimum=0.1, maximum=2.0, step=0.1, label="temperature: Increase these for more diverse, but lower quality, generations")
+        level_size = gr.Slider(value=1399, minimum=100, maximum=2799, step=1, label="level_size")
+    
+    btn = gr.Button("Generate level")
+    with gr.Row():
+        with gr.Group():
+            level_play = gr.HTML()    
+        level_image = gr.Image()
+    btn.click(fn=generate, inputs=[pipes, enemies, blocks, elevation, temperature, level_size, text_prompt], outputs=[level_image, level_play])
+    gr.Examples(
+        examples=[
+            ["many", "many", "some", "high"],
+            ["no", "some", "many", "high"],
+            ["many", "many", "little", "low"],
+            ["no", "no", "many", "high"],
+        ],
+        inputs=[pipes, enemies, blocks, elevation],
+        outputs=[level_image, level_play],
+        fn=generate,
+        cache_examples=True,
+    )
+
+# Mount static files and Gradio app
+app.mount("/static", StaticFiles(directory="static", html=True), name="static")
+app = gr.mount_gradio_app(app, demo, "/")
 
 if __name__ == "__main__":
-    app.launch(
-        mcp_server=True,  # Enable MCP server
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        theme=gr.themes.Soft()
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860)