Update app.py

app.py

@@ -1,3 +1,482 @@
+## 🚨 Hugging Face Space 503 Error - Need Code Fix
+
+I have a persistent 503 "Something went wrong when restarting this Space" error with my Hugging Face Space. The local server works perfectly, but the HF deployment fails. Here's my complete setup:
+
+### 📋 Project Overview
+**SuperCoder** - AI coding assistant running locally with Ollama, accessible via HF Space web interface
+- **Local Backend:** Python server using Ollama models
+- **Web Frontend:** Gradio interface on Hugging Face Space  
+- **Connection:** ngrok tunnel from HF to local server
+
+### 🏠 Complete Local Setup (All Working)
+
+#### 1. requirements.txt (Local)
+```txt
+gradio>=4.0.0
+requests>=2.25.0
+2. config.py (Local - 3,798 bytes)
+python
+"""
+Configuration and constants for SuperCoder.
+Centralized settings for easy maintenance and deployment.
+"""
+import os
+from pathlib import Path
+
+# ============================================================================
+# Model Configuration (llama.cpp Server)
+# ============================================================================
+LLAMA_SERVER_PATH = "/Users/izumotofam/llama.cpp/build/bin/llama-server"
+LLAMA_MODEL = "llama2:latest"
+LLAMA_SERVER_HOST = "127.0.0.1"
+LLAMA_SERVER_PORT = 8080
+LLAMA_SERVER_URL = "http://localhost:11434"
+
+# Server startup settings
+SERVER_STARTUP_TIMEOUT = 30  # seconds to wait for server to start
+SERVER_HEALTH_CHECK_INTERVAL = 0.5  # seconds between health checks
+
+# Model parameters
+MODEL_THREADS = 1
+MODEL_CONTEXT_WINDOW = 1024
+MODEL_GPU_LAYERS = 0
+MODEL_BATCH_SIZE = 64
+
+# Gradio UI settings
+SERVER_NAME = "127.0.0.1"
+SERVER_PORT = 7860
+APP_TITLE = "SuperCoder Pro"
+APP_DESCRIPTION = "AI-Powered Coding Assistant"
+CHAT_HEIGHT = 500
+
+# Model settings
+DEFAULT_TEMPERATURE = 0.1
+DEFAULT_MAX_TOKENS = 512
+DEFAULT_TOP_P = 0.9
+MIN_TOKENS = 128
+SAFE_MAX_TOKENS_CAP = 2048
+SYSTEM_OVERHEAD_TOKENS = 100
+3. supercoder.py (Local Backend - 413 lines - DON'T upload to HF)
+python
+"""
+SuperCoder - Unified Application
+All-in-one file containing Gradio UI, API server, tunnel support, and AI logic.
+"""
+import os
+import sys
+import time
+import uuid
+import argparse
+import subprocess
+import traceback
+import requests
+import json
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Generator, Tuple
+from collections import defaultdict
+from functools import partial
+from multiprocessing import Process
+
+import gradio as gr
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+
+# Import config (only external dependency)
+from config import *
+
+# ============================================================================
+# SERVER MANAGER - llama.cpp server lifecycle
+# ============================================================================
+_server_process = None
+_server_info = {}
+
+def check_server_health() -> bool:
+    try:
+        # Check if Ollama is responding
+        response = requests.get(f"{LLAMA_SERVER_URL}/api/tags", timeout=2)
+        return response.status_code == 200 and len(response.json().get("models", [])) > 0
+    except:
+        return False
+
+def start_llama_server() -> bool:
+    global _server_process, _server_info
+    
+    if _server_process and check_server_health():
+        return True
+    
+    print(f"\n🚀 Starting llama.cpp server on {LLAMA_SERVER_URL}")
+    
+    try:
+        cmd = [
+            LLAMA_SERVER_PATH, "-hf", LLAMA_MODEL,
+            "-c", str(MODEL_CONTEXT_WINDOW),
+            "-t", str(MODEL_THREADS),
+            "-ngl", str(MODEL_GPU_LAYERS),
+            "--host", LLAMA_SERVER_HOST, "--port", str(LLAMA_SERVER_PORT)
+        ]
+        
+        _server_process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        _server_info = {'pid': _server_process.pid, 'url': LLAMA_SERVER_URL}
+        
+        # Wait for ready
+        for _ in range(SERVER_STARTUP_TIMEOUT * 2):
+            if check_server_health():
+                print(f"✅ Server ready (PID: {_server_process.pid})")
+                return True
+            time.sleep(0.5)
+        
+        return False
+    except Exception as e:
+        print(f"❌ Server start failed: {e}")
+        return False
+
+def stop_llama_server():
+    global _server_process
+    if _server_process:
+        _server_process.terminate()
+        _server_process.wait()
+        _server_process = None
+
+def get_llm():
+    return True if check_server_health() else None
+
+def get_model_info():
+    return _server_info.copy()
+
+# ============================================================================
+# SESSION MANAGER - Chat history
+# ============================================================================
+SESSION_STORE = {}
+SESSION_METADATA = defaultdict(dict)
+
+def get_session_id(request: gr.Request) -> str:
+    return request.session_hash
+
+def get_history(session_id: str, create_if_missing: bool = False) -> List[Dict]:
+    if session_id not in SESSION_STORE and create_if_missing:
+        SESSION_STORE[session_id] = []
+    return SESSION_STORE.get(session_id, [])
+
+def add_to_history(session_id: str, role: str, text: str):
+    history = get_history(session_id, create_if_missing=True)
+    history.append({"role": role, "text": text, "timestamp": time.time()})
+
+def clear_history(session_id: str):
+    if session_id in SESSION_STORE:
+        SESSION_STORE[session_id] = []
+
+def convert_history_to_gradio_messages(history: List[Dict]) -> List[Dict]:
+    return [{"role": msg["role"], "content": msg["text"]} for msg in history]
+
+def calculate_safe_max_tokens(history: List[Dict], requested: int, max_context: int) -> int:
+    history_chars = sum(len(msg["text"]) for msg in history)
+    estimated_tokens = history_chars // 4
+    available = max_context - estimated_tokens - SYSTEM_OVERHEAD_TOKENS
+    return max(min(requested, available, SAFE_MAX_TOKENS_CAP), MIN_TOKENS)
+
+def get_recent_history(session_id: str, max_messages: int = 10) -> List[Dict]:
+    history = get_history(session_id)
+    return history[-max_messages:] if len(history) > max_messages else history
+
+def update_session_activity(session_id: str):
+    SESSION_METADATA[session_id]['last_activity'] = time.time()
+
+# ============================================================================
+# GENERATION - AI response generation
+# ============================================================================
+def generate_response_stream(session_id: str, user_message: str, max_tokens: int, 
+                            temperature: float, stream: bool = True) -> Generator[str, None, None]:
+    if not get_llm():
+        yield "⚠️ Server not running"
+        return
+
+    update_session_activity(session_id)
+    recent_history = get_recent_history(session_id, max_messages=6)
+    safe_tokens = calculate_safe_max_tokens(recent_history, max_tokens, MODEL_CONTEXT_WINDOW)
+    
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    for msg in recent_history:
+        messages.append({"role": msg["role"], "content": msg["text"]})
+    messages.append({"role": "user", "content": user_message})
+    
+    try:
+        payload = {
+            "messages": messages, "max_tokens": safe_tokens,
+            "temperature": max(0.01, temperature),
+            "top_p": DEFAULT_TOP_P, "stream": stream
+        }
+        
+        if stream:
+            response = requests.post(f"{LLAMA_SERVER_URL}/v1/chat/completions", 
+                                   json=payload, stream=True, timeout=300)
+            full_response = ""
+            for line in response.iter_lines():
+                if line:
+                    line_text = line.decode('utf-8')
+                    if line_text.startswith('data: '):
+                        line_text = line_text[6:]
+                    if line_text.strip() == '[DONE]':
+                        break
+                    try:
+                        chunk = json.loads(line_text)
+                        content = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                        if content:
+                            full_response += content
+                            yield full_response.strip()
+                    except:
+                        continue
+        else:
+            # Use Ollama API format instead of OpenAI format
+            ollama_payload = {
+                "model": LLAMA_MODEL,
+                "messages": messages,
+                "stream": False
+            }
+            response = requests.post(f"{LLAMA_SERVER_URL}/api/chat", 
+                                   json=ollama_payload, timeout=300)
+            yield response.json()["message"]["content"].strip()
+            
+    except Exception as e:
+        yield f"⚠️ Error: {str(e)}"
+
+# ============================================================================
+# GRADIO UI COMPONENTS
+# ============================================================================
+def create_gradio_interface(error_msg: Optional[str] = None):
+    with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft(primary_hue=PRIMARY_HUE)) as demo:
+        gr.Markdown(f"# 🤖 {APP_TITLE}\n### {APP_DESCRIPTION}\n---")
+        
+        if error_msg:
+            gr.Markdown(f"⚠️ {error_msg}")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(label="💬 Conversation", height=CHAT_HEIGHT, 
+                                   type="messages", show_copy_button=True)
+                with gr.Row():
+                    txt_input = gr.Textbox(placeholder="Ask me about code...", 
+                                         show_label=False, scale=5, lines=2)
+                    send_btn = gr.Button("Send 🚀", scale=1, variant="primary")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚙️ Settings")
+                temp_slider = gr.Slider(0.0, 1.0, value=DEFAULT_TEMPERATURE, step=0.05,
+                                      label="🌡️ Temperature")
+                tokens_slider = gr.Slider(MIN_TOKENS, SAFE_MAX_TOKENS_CAP, 
+                                        value=DEFAULT_MAX_TOKENS, step=128, label="📏 Max Tokens")
+                stream_checkbox = gr.Checkbox(label="⚡ Stream", value=True)
+                clear_btn = gr.Button("🗑️ Clear", variant="stop", size="sm")
+        
+        session_state = gr.State()
+        
+        # Event handlers
+        def handle_message(session_id, msg, temp, tokens, stream, request: gr.Request):
+            session_id = session_id or get_session_id(request)
+            if not msg.strip():
+                return session_id, convert_history_to_gradio_messages(get_history(session_id)), ""
+            
+            add_to_history(session_id, "user", msg)
+            yield session_id, convert_history_to_gradio_messages(get_history(session_id)), ""
+            
+            full_response = ""
+            for partial in generate_response_stream(session_id, msg, tokens, temp, stream):
+                full_response = partial
+                temp_hist = get_history(session_id).copy()
+                temp_hist.append({"role": "assistant", "text": full_response})
+                yield session_id, convert_history_to_gradio_messages(temp_hist), ""
+            
+            add_to_history(session_id, "assistant", full_response)
+            yield session_id, convert_history_to_gradio_messages(get_history(session_id)), ""
+        
+        def handle_clear(session_id, request: gr.Request):
+            session_id = session_id or get_session_id(request)
+            clear_history(session_id)
+            return session_id, [], ""
+        
+        txt_input.submit(handle_message, [session_state, txt_input, temp_slider, tokens_slider, stream_checkbox],
+                        [session_state, chatbot, txt_input])
+        send_btn.click(handle_message, [session_state, txt_input, temp_slider, tokens_slider, stream_checkbox],
+                      [session_state, chatbot, txt_input])
+        clear_btn.click(handle_clear, [session_state], [session_state, chatbot, txt_input])
+    
+    return demo
+
+# ============================================================================
+# FASTAPI SERVER
+# ============================================================================
+api_app = FastAPI(title="SuperCoder API")
+api_app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+api_sessions = {}
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.1
+    max_tokens: Optional[int] = 512
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+
+@api_app.get("/health")
+async def health():
+    return {"status": "ok" if get_llm() else "model_not_loaded"}
+
+@api_app.post("/api/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    if not get_llm():
+        raise HTTPException(503, "Model not loaded")
+    
+    session_id = str(uuid.uuid4())
+    api_sessions[session_id] = []
+    
+    user_message = request.messages[-1].content
+    api_sessions[session_id].append({"role": "user", "text": user_message})
+    
+    full_response = ""
+    for partial in generate_response_stream(session_id, user_message, request.max_tokens, 
+                                          request.temperature, False):
+        full_response = partial
+    
+    api_sessions[session_id].append({"role": "assistant", "text": full_response})
+    return ChatResponse(response=full_response, session_id=session_id)
+
+def run_api_server():
+    uvicorn.run(api_app, host="0.0.0.0", port=8000, log_level="info")
+
+# ============================================================================
+# TUNNEL SUPPORT
+# ============================================================================
+def start_ngrok_tunnel(port: int = 8000) -> Optional[str]:
+    try:
+        subprocess.run(["which", "ngrok"], capture_output=True, check=True)
+        subprocess.Popen(["ngrok", "http", str(port)], stdout=subprocess.PIPE)
+        time.sleep(3)
+        
+        response = requests.get("http://127.0.0.1:4040/api/tunnels", timeout=5)
+        tunnels = response.json()
+        if tunnels.get("tunnels"):
+            url = tunnels["tunnels"][0]["public_url"]
+            print(f"✅ Tunnel: {url}")
+            return url
+    except:
+        print("❌ ngrok not found. Install: brew install ngrok")
+    return None
+
+def start_cloudflare_tunnel(port: int = 8000) -> Optional[str]:
+    try:
+        subprocess.run(["which", "cloudflared"], capture_output=True, check=True)
+        proc = subprocess.Popen(["cloudflared", "tunnel", "--url", f"http://localhost:{port}"],
+                              stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        time.sleep(3)
+        
+        for _ in range(30):
+            line = proc.stdout.readline()
+            if "trycloudflare.com" in line:
+                import re
+                urls = re.findall(r'https://[^\s]+\.trycloudflare\.com', line)
+                if urls:
+                    print(f"✅ Tunnel: {urls[0]}")
+                    return urls[0]
+            time.sleep(1)
+    except:
+        print("❌ cloudflared not found. Install: brew install cloudflared")
+    return None
+
+# ============================================================================
+# MAIN LAUNCHER
+# ============================================================================
+def main():
+    parser = argparse.ArgumentParser(description="SuperCoder - All-in-One AI Coding Assistant")
+    parser.add_argument("--mode", choices=["gradio", "api", "both"], default="gradio",
+                       help="Run mode: gradio (UI), api (server), or both")
+    parser.add_argument("--tunnel", choices=["ngrok", "cloudflare"], 
+                       help="Start tunnel for public access")
+    parser.add_argument("--no-server", action="store_true",
+                       help="Don't start llama.cpp server (assume already running)")
+    
+    args = parser.parse_args()
+    
+    print("╔════════════════════════════════════════════════╗")
+    print("║         SuperCoder - Unified Launcher          ║")
+    print("╚════════════════════════════════════════════════╝")
+    
+    # Start llama.cpp server
+    if not args.no_server:
+        success = start_llama_server()
+        error_msg = None if success else "Failed to start llama.cpp server"
+    else:
+        error_msg = None
+    
+    # Run selected mode
+    if args.mode == "gradio":
+        print(f"\n📌 Mode: Gradio UI\n🌐 Access: http://localhost:{SERVER_PORT}\n")
+        demo = create_gradio_interface(error_msg)
+        demo.launch(server_name=SERVER_NAME, server_port=SERVER_PORT)
+    
+    elif args.mode == "api":
+        print(f"\n📌 Mode: API Server\n📡 API: http://localhost:8000/api/chat\n")
+        
+        if args.tunnel:
+            api_proc = Process(target=run_api_server)
+            api_proc.start()
+            time.sleep(3)
+            
+            if args.tunnel == "ngrok":
+                start_ngrok_tunnel(8000)
+            else:
+                start_cloudflare_tunnel(8000)
+            
+            try:
+                api_proc.join()
+            except KeyboardInterrupt:
+                api_proc.terminate()
+        else:
+            run_api_server()
+    
+    elif args.mode == "both":
+        print(f"\n📌 Mode: Both Gradio + API\n🎨 UI: http://localhost:{SERVER_PORT}\n📡 API: http://localhost:8000\n")
+        
+        gradio_proc = Process(target=lambda: create_gradio_interface(error_msg).launch(
+            server_name=SERVER_NAME, server_port=SERVER_PORT))
+        api_proc = Process(target=run_api_server)
+        
+        gradio_proc.start()
+        api_proc.start()
+        
+        if args.tunnel:
+            time.sleep(3)
+            if args.tunnel == "ngrok":
+                start_ngrok_tunnel(8000)
+            else:
+                start_cloudflare_tunnel(8000)
+        
+        try:
+            gradio_proc.join()
+            api_proc.join()
+        except KeyboardInterrupt:
+            gradio_proc.terminate()
+            api_proc.terminate()
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n👋 Shutting down...")
+        stop_llama_server()
+🌐 Hugging Face Space Setup (Currently Broken)
+Current HF Space Files:
+Space: https://huggingface.co/spaces/SeccondDefense/Advanced_AI_Coder
+Error: 503 Something went wrong when restarting this Space
+Request ID: Root=1-68e635bc-446c06181ed65dee7e15e4f5
+4. app.py (HF Frontend - Currently uploaded to HF)
+python
 """
 SuperCoder - Hugging Face Spaces Frontend
 Connects to your local API server via tunnel
@@ -11,17 +490,8 @@ from typing import List, Tuple
 # ============================================================================
 API_URL = "https://inge-chalcographic-helene.ngrok-free.dev"
 
-# Example URLs:
-# ngrok: https://abc123.ngrok-free.app
-# cloudflare: https://abc123.trycloudflare.com
-
-# ============================================================================
 # API Client Functions
-# ============================================================================
 def call_api(message: str, temperature: float = 0.1, max_tokens: int = 512) -> str:
-    """
-    Call the SuperCoder API running on your local machine.
-    """
     try:
         response = requests.post(
             f"{API_URL}/api/chat",
@@ -33,25 +503,19 @@ def call_api(message: str, temperature: float = 0.1, max_tokens: int = 512) -> s
             },
             timeout=60
         )
-
         if response.status_code == 200:
             result = response.json()
             return result.get("response", "No response from API")
         else:
             return f"❌ API Error ({response.status_code}): {response.text}"
-
     except requests.exceptions.Timeout:
         return "⏱️ Request timed out. The model might be processing a complex request."
-
     except requests.exceptions.ConnectionError:
         return "🔌 Connection failed. Please ensure your local API server is running."
-
     except Exception as e:
         return f"⚠️ Error: {str(e)}"
 
-
 def check_api_status() -> str:
-    """Check if the API is reachable."""
     try:
         response = requests.get(f"{API_URL}/health", timeout=5)
         if response.status_code == 200:
@@ -65,192 +529,72 @@ def check_api_status() -> str:
     except:
         return "🔴 Not connected to API"
 
-
-# ============================================================================
-# Gradio Interface
-# ============================================================================
-def chat_interface(message: str, history: List[Tuple[str, str]],
-                  temperature: float, max_tokens: int) -> Tuple[List[Tuple[str, str]], str]:
-    """Handle chat interaction."""
-    if not message.strip():
-        return history, ""
-
-    # Add user message to history
-    history = history + [(message, None)]
-
-    # Get AI response
-    response = call_api(message, temperature, max_tokens)
-
-    # Update history with response
-    history[-1] = (message, response)
-
-    return history, ""
-
-
-# ============================================================================
-# Quick Action Templates
-# ============================================================================
-QUICK_ACTIONS = {
-    "Explain Code": "Explain the following code:\n\n```python\n# PASTE YOUR CODE HERE\n```",
-    "Debug Code": "Help me debug this code:\n\n```python\n# PASTE YOUR CODE HERE\n```",
-    "Write Function": "Write a Python function that:",
-    "Optimize Code": "Optimize this code for better performance:\n\n```python\n# PASTE YOUR CODE HERE\n```",
-    "Add Comments": "Add detailed comments to this code:\n\n```python\n# PASTE YOUR CODE HERE\n```",
-}
-
-def use_template(template_name: str) -> str:
-    """Return the selected template."""
-    return QUICK_ACTIONS.get(template_name, "")
-
-
-# ============================================================================
-# Build Gradio UI
-# ============================================================================
-with gr.Blocks(
-    title="SuperCoder Pro",
-    theme=gr.themes.Soft(primary_hue="indigo"),
-    css="""
-    .container { max-width: 1200px; margin: auto; }
-    .status-box { padding: 10px; border-radius: 5px; margin: 10px 0; }
-    .status-connected { background-color: #d4edda; }
-    .status-disconnected { background-color: #f8d7da; }
-    """
-) as demo:
-
-    # Header
-    gr.Markdown("""
-    # 🤖 SuperCoder Pro
-    ### AI-Powered Coding Assistant
-
-    Your personal AI coding assistant powered by local hardware. Ask me to write,
-    explain, debug, or optimize code!
-
-    ---
-    """)
-
-    # API Status
+# Gradio Interface (Complete UI)
+with gr.Blocks(title="SuperCoder Pro", theme=gr.themes.Soft(primary_hue="indigo")) as demo:
+    gr.Markdown("# 🤖 SuperCoder Pro\n### AI-Powered Coding Assistant")
+    
     with gr.Row():
-        status_text = gr.Textbox(
-            value=check_api_status(),
-            label="🔌 API Status",
-            interactive=False,
-            show_label=True
-        )
+        status_text = gr.Textbox(value=check_api_status(), label="🔌 API Status")
         refresh_btn = gr.Button("🔄 Refresh Status", size="sm")
-
-    refresh_btn.click(
-        fn=check_api_status,
-        outputs=status_text
-    )
-
-    # Main Interface
+    
     with gr.Row():
-        # Left Column: Chat
         with gr.Column(scale=3):
-            chatbot = gr.Chatbot(
-                label="💬 Conversation",
-                height=500,
-                show_copy_button=True,
-                avatar_images=(None, "🤖")
-            )
-
+            chatbot = gr.Chatbot(label="💬 Conversation", height=500)
             with gr.Row():
-                msg_input = gr.Textbox(
-                    placeholder="Ask me to write, explain, debug, or review code...",
-                    show_label=False,
-                    scale=5,
-                    lines=2
-                )
+                msg_input = gr.Textbox(placeholder="Ask me to write, explain, debug, or review code...", scale=5, lines=2)
                 send_btn = gr.Button("Send 🚀", scale=1, variant="primary")
-
-        # Right Column: Settings & Actions
+        
         with gr.Column(scale=1):
             gr.Markdown("### ⚙️ Settings")
-
-            temperature = gr.Slider(
-                0.0, 1.0,
-                value=0.1,
-                step=0.05,
-                label="🌡️ Temperature",
-                info="Lower = precise, Higher = creative"
-            )
-
-            max_tokens = gr.Slider(
-                128, 2048,
-                value=512,
-                step=128,
-                label="📏 Max Tokens",
-                info="Response length limit"
-            )
-
+            temperature = gr.Slider(0.0, 1.0, value=0.1, step=0.05, label="🌡️ Temperature")
+            max_tokens = gr.Slider(128, 2048, value=512, step=128, label="📏 Max Tokens")
             gr.Markdown("### 🎯 Quick Actions")
-
-            template_dropdown = gr.Dropdown(
-                choices=list(QUICK_ACTIONS.keys()),
-                label="Select Template",
-                value=None
-            )
-
+            template_dropdown = gr.Dropdown(choices=["Explain Code", "Debug Code", "Write Function", "Optimize Code", "Add Comments"], label="Select Template")
             use_template_btn = gr.Button("Use Template", size="sm")
-
             clear_btn = gr.Button("🗑️ Clear Chat", variant="stop", size="sm")
+    
+    # Event handlers
+    msg_input.submit(lambda m, h, t, mt: (h + [(m, call_api(m, t, mt))], ""), 
+                    [msg_input, chatbot, temperature, max_tokens], [chatbot, msg_input])
+    send_btn.click(lambda m, h, t, mt: (h + [(m, call_api(m, t, mt))], ""), 
+                  [msg_input, chatbot, temperature, max_tokens], [chatbot, msg_input])
+    refresh_btn.click(lambda: check_api_status(), outputs=status_text)
 
-    # Event Handlers
-    msg_input.submit(
-        fn=chat_interface,
-        inputs=[msg_input, chatbot, temperature, max_tokens],
-        outputs=[chatbot, msg_input]
-    )
-
-    send_btn.click(
-        fn=chat_interface,
-        inputs=[msg_input, chatbot, temperature, max_tokens],
-        outputs=[chatbot, msg_input]
-    )
-
-    use_template_btn.click(
-        fn=use_template,
-        inputs=[template_dropdown],
-        outputs=[msg_input]
-    )
-
-    clear_btn.click(
-        fn=lambda: ([], ""),
-        outputs=[chatbot, msg_input]
-    )
-
-    # Footer
-    gr.Markdown("""
-    ---
-
-    ### 💡 Tips
-    - **Be specific** in your requests for better results
-    - **Paste code** directly in your messages
-    - Use **templates** for common tasks
-    - Adjust **temperature** for more creative or precise outputs
-
-    ### ⚠️ Important
-    This Space connects to a **locally-running** AI model via tunnel.
-    If you see connection errors, the local server may be offline.
-
-    ### 🔒 Privacy
-    - All processing happens on the owner's local machine
-    - No data is stored by Hugging Face
-    - Each chat session is independent
-
-    ---
-
-    **Built with ❤️ using llama.cpp and Gradio**
-    """)
-
-
-# ============================================================================
-# HF Spaces Launch Configuration
-# ============================================================================
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        share=False  # Important for HF Spaces compatibility
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True, share=False)
+🔧 Current Status
+✅ Working:
+Local server: python supercoder.py --mode api runs successfully
+Ollama: llama2:latest model loaded and responding
+ngrok tunnel: https://inge-chalcographic-helene.ngrok-free.dev active
+File syntax: All Python files parse correctly
+❌ Broken:
+HF Space: 503 Something went wrong when restarting this Space
+File uploads: May not be working properly via CLI
+Space deployment: Failing to start properly
+🎯 Expected vs Actual
+Expected Behavior:
+
+HF Space loads Gradio interface
+Connects to local server via tunnel
+Users can chat with AI assistant
+Settings and templates work
+Actual Behavior:
+
+HF Space shows 503 error
+Cannot access the web interface
+Files may not be properly deployed
+❓ Request for Fix
+Please analyze all the provided code and tell me:
+
+What's causing the 503 error in the HF Space?
+How to fix the code so it works on HF Spaces?
+Are there missing dependencies or configuration issues?
+Should I modify the launch configuration for HF compatibility?
+Is there a better way to structure this for HF deployment?
+Provide the corrected, working code for both local and HF files.
+
+The local setup works perfectly - the issue is specifically with HF Space deployment.
+
+
+---