Restructure app to use Gradio's native launch for ZeroGPU

- Remove FastAPI-first approach that was breaking ZeroGPU detection
- Use demo.app to add API routes to Gradio's internal FastAPI app
- Use demo.launch() only for local development
- Keep demo object exposed for HF Spaces runtime

app.py

@@ -12,25 +12,16 @@ This Gradio app provides:
 # Import spaces FIRST - required for ZeroGPU GPU detection
 import spaces
 
-# Define a GPU function immediately after importing spaces
-# This ensures ZeroGPU detects it at startup
-@spaces.GPU(duration=60)
-def _zerogpu_test():
-    """Test function for ZeroGPU detection."""
-    return True
-
 import logging
 import time
 from typing import Optional
 
 import gradio as gr
 import httpx
-from fastapi import Header, HTTPException
+from fastapi import Header, HTTPException, Request
 from fastapi.responses import StreamingResponse, JSONResponse
 from huggingface_hub import HfApi
 
-ZEROGPU_AVAILABLE = True
-
 from config import get_config, get_quota_tracker
 from models import (
     apply_chat_template,
@@ -55,6 +46,8 @@ quota_tracker = get_quota_tracker()
 # HuggingFace API for token validation
 hf_api = HfApi()
 
+ZEROGPU_AVAILABLE = True
+
 
 # --- Authentication ---
 
@@ -82,17 +75,8 @@ def extract_token(authorization: Optional[str]) -> Optional[str]:
     return authorization
 
 
-# --- ZeroGPU Inference ---
-
-
-# Simple GPU function for ZeroGPU detection at startup
-@spaces.GPU(duration=60)
-def gpu_warmup():
-    """Warmup function to ensure ZeroGPU detects GPU usage."""
-    import torch
-    if torch.cuda.is_available():
-        return f"GPU available: {torch.cuda.get_device_name(0)}"
-    return "No GPU detected"
+# --- ZeroGPU Inference Functions ---
+# These MUST be decorated with @spaces.GPU for ZeroGPU detection
 
 
 @spaces.GPU(duration=120)
@@ -201,7 +185,7 @@ async def serverless_generate(
         )
 
 
-# --- Gradio Interface ---
+# --- Gradio Chat Function (GPU decorated for ZeroGPU) ---
 
 
 @spaces.GPU(duration=120)
@@ -246,26 +230,108 @@ def gradio_chat(
         return f"Error generating response: {str(e)}"
 
 
-# --- FastAPI app for OpenAI-compatible routes ---
-from fastapi import FastAPI
+# --- Build Gradio Interface ---
 
-api_app = FastAPI(
-    title="ZeroGPU OpenCode Provider",
-    description="OpenAI-compatible API for HuggingFace models on ZeroGPU",
-    version="1.0.0",
-)
+with gr.Blocks(title="ZeroGPU OpenCode Provider") as demo:
+    gr.Markdown(
+        """
+        # ZeroGPU OpenCode Provider
+
+        OpenAI-compatible inference endpoint for [opencode](https://github.com/sst/opencode).
+
+        **API Endpoint:** `/v1/chat/completions`
+
+        ## Usage with opencode
+
+        Configure in `~/.config/opencode/opencode.json`:
+
+        ```json
+        {
+          "providers": {
+            "zerogpu": {
+              "npm": "@ai-sdk/openai-compatible",
+              "options": {
+                "baseURL": "https://serenichron-opencode-zerogpu.hf.space/v1",
+                "headers": {
+                  "Authorization": "Bearer hf_YOUR_TOKEN"
+                }
+              },
+              "models": {
+                "llama-8b": {
+                  "name": "meta-llama/Llama-3.1-8B-Instruct"
+                }
+              }
+            }
+          }
+        }
+        ```
+
+        ---
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            model_dropdown = gr.Dropdown(
+                label="Model",
+                choices=[
+                    "meta-llama/Llama-3.1-8B-Instruct",
+                    "mistralai/Mistral-7B-Instruct-v0.3",
+                    "Qwen/Qwen2.5-7B-Instruct",
+                    "Qwen/Qwen2.5-14B-Instruct",
+                ],
+                value="meta-llama/Llama-3.1-8B-Instruct",
+                allow_custom_value=True,
+            )
+            temperature_slider = gr.Slider(
+                label="Temperature",
+                minimum=0.0,
+                maximum=2.0,
+                value=0.7,
+                step=0.1,
+            )
+            max_tokens_slider = gr.Slider(
+                label="Max Tokens",
+                minimum=64,
+                maximum=4096,
+                value=512,
+                step=64,
+            )
 
+            gr.Markdown(
+                f"""
+                ### Status
+                - **ZeroGPU:** {'Available' if ZEROGPU_AVAILABLE else 'Not Available'}
+                - **Fallback:** {'Enabled' if config.fallback_enabled else 'Disabled'}
+                """
+            )
 
-@api_app.post("/v1/chat/completions")
+        with gr.Column(scale=3):
+            chatbot = gr.ChatInterface(
+                fn=gradio_chat,
+                additional_inputs=[model_dropdown, temperature_slider, max_tokens_slider],
+                title="",
+            )
+
+
+# --- Add OpenAI-compatible API routes to Gradio's internal FastAPI app ---
+
+# Get the underlying FastAPI app from Gradio
+app = demo.app
+
+
+@app.post("/v1/chat/completions")
 async def chat_completions(
-    request: ChatCompletionRequest,
-    authorization: Optional[str] = Header(None),
+    request: Request,
 ):
     """
     OpenAI-compatible chat completions endpoint.
 
     Supports both streaming and non-streaming responses.
     """
+    # Get authorization header
+    authorization = request.headers.get("authorization")
+
     # Validate authentication
     token = extract_token(authorization)
     if not token or not validate_hf_token(token):
@@ -278,8 +344,21 @@ async def chat_completions(
             ).model_dump(),
         )
 
+    # Parse request body
+    try:
+        body = await request.json()
+        chat_request = ChatCompletionRequest(**body)
+    except Exception as e:
+        return JSONResponse(
+            status_code=400,
+            content=create_error_response(
+                message=f"Invalid request body: {str(e)}",
+                error_type="invalid_request_error",
+            ).model_dump(),
+        )
+
     # Extract inference parameters
-    params = InferenceParams.from_request(request)
+    params = InferenceParams.from_request(chat_request)
 
     # Apply chat template
     try:
@@ -392,9 +471,10 @@ async def chat_completions(
         )
 
 
-@api_app.get("/v1/models")
-async def list_models(authorization: Optional[str] = Header(None)):
+@app.get("/v1/models")
+async def list_models(request: Request):
     """List available models (returns info about current model if loaded)."""
+    authorization = request.headers.get("authorization")
     token = extract_token(authorization)
     if not token or not validate_hf_token(token):
         return JSONResponse(
@@ -422,7 +502,7 @@ async def list_models(authorization: Optional[str] = Header(None)):
     return {"object": "list", "data": models}
 
 
-@api_app.get("/health")
+@app.get("/health")
 async def health_check():
     """Health check endpoint."""
     return {
@@ -433,102 +513,10 @@ async def health_check():
     }
 
 
-# Build Gradio Blocks interface
-with gr.Blocks(title="ZeroGPU OpenCode Provider") as demo:
-    gr.Markdown(
-        """
-        # ZeroGPU OpenCode Provider
-
-        OpenAI-compatible inference endpoint for [opencode](https://github.com/sst/opencode).
-
-        **API Endpoint:** `/v1/chat/completions`
-
-        ## Usage with opencode
-
-        Configure in `~/.config/opencode/opencode.json`:
-
-        ```json
-        {
-          "providers": {
-            "zerogpu": {
-              "npm": "@ai-sdk/openai-compatible",
-              "options": {
-                "baseURL": "https://serenichron-opencode-zerogpu.hf.space/v1",
-                "headers": {
-                  "Authorization": "Bearer hf_YOUR_TOKEN"
-                }
-              },
-              "models": {
-                "llama-8b": {
-                  "name": "meta-llama/Llama-3.1-8B-Instruct"
-                }
-              }
-            }
-          }
-        }
-        ```
-
-        ---
-        """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            model_dropdown = gr.Dropdown(
-                label="Model",
-                choices=[
-                    "meta-llama/Llama-3.1-8B-Instruct",
-                    "mistralai/Mistral-7B-Instruct-v0.3",
-                    "Qwen/Qwen2.5-7B-Instruct",
-                    "Qwen/Qwen2.5-14B-Instruct",
-                ],
-                value="meta-llama/Llama-3.1-8B-Instruct",
-                allow_custom_value=True,
-            )
-            temperature_slider = gr.Slider(
-                label="Temperature",
-                minimum=0.0,
-                maximum=2.0,
-                value=0.7,
-                step=0.1,
-            )
-            max_tokens_slider = gr.Slider(
-                label="Max Tokens",
-                minimum=64,
-                maximum=4096,
-                value=512,
-                step=64,
-            )
-
-            gr.Markdown(
-                f"""
-                ### Status
-                - **ZeroGPU:** {'Available' if ZEROGPU_AVAILABLE else 'Not Available'}
-                - **Fallback:** {'Enabled' if config.fallback_enabled else 'Disabled'}
-                """
-            )
-
-        with gr.Column(scale=3):
-            chatbot = gr.ChatInterface(
-                fn=gradio_chat,
-                additional_inputs=[model_dropdown, temperature_slider, max_tokens_slider],
-                title="",
-            )
-
-
-# Add redirect from root to /ui for convenience
-from fastapi.responses import RedirectResponse
-
-@api_app.get("/", include_in_schema=False)
-async def redirect_to_ui():
-    """Redirect root to Gradio UI."""
-    return RedirectResponse(url="/ui")
-
-
-# Mount Gradio into FastAPI app at /ui, API at root level
-app = gr.mount_gradio_app(api_app, demo, path="/ui")
-
+# --- Launch the application ---
+# On HuggingFace Spaces, the runtime handles the launch automatically
+# The demo object is exposed for the Gradio SDK to use
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    # Local development
+    demo.launch(server_name="0.0.0.0", server_port=7860)