rewrite: use gradio.Server + @app .api() + custom HTML (proper Gradio 6.x pattern)

app.py

@@ -1,9 +1,9 @@
 """SoniCoder v2 — Entry point.
 
-Uses gradio.Server (Gradio 6.x) to serve a custom HTML frontend
+gradio.Server (Gradio 6.x) serves index.html from project root
 with Gradio's queuing, concurrency, and API infrastructure.
 
-Read: https://huggingface.co/blog/introducing-gradio-server
+Blog: https://huggingface.co/blog/introducing-gradio-server
 """
 
 from __future__ import annotations
@@ -50,9 +50,7 @@ def main():
     from sonicoder.server import create_app
     app = create_app()
 
-    # Launch
-    port = int(os.environ.get("PORT", 7860))
-    logger.info(f"Launching on port {port}")
+    logger.info("Launching...")
     app.launch(show_error=True)
 
 

sonicoder/server/__init__.py

@@ -1,8 +1,13 @@
-"""Server routes — using gradio.Server (Gradio 6.x pattern).
+"""Server routes — using gradio.Server (Gradio 6.x).
 
-Read the blog: https://huggingface.co/blog/introducing-gradio-server
-gradio.Server extends FastAPI. @app.api() gives queuing + concurrency.
-@app.get("/") serves custom HTML frontend directly.
+Blog: https://huggingface.co/blog/introducing-gradio-server
+
+Pattern:
+  - from gradio import Server  (NOT gradio.Server())
+  - @app.api(name="...") for backend endpoints  →  gets Gradio queuing + concurrency
+  - @app.post("/chat") raw FastAPI route for SSE streaming
+  - @app.get("/", response_class=HTMLResponse) serves index.html from project root
+  - Frontend uses @gradio/client JS for non-streaming, raw fetch for streaming
 """
 
 from __future__ import annotations
@@ -14,12 +19,15 @@ import uuid
 from pathlib import Path
 from typing import Any, Generator
 
+from fastapi import Request
+from fastapi.responses import HTMLResponse, StreamingResponse
+
 from ..config import (
     Settings, get_available_models, load_settings,
     WORKSPACE_ROOT, CONFIG_DIR,
 )
 from ..model.loader import (
-    get_model_status, start_background_load, switch_model,
+    get_model_status, start_background_load, switch_model as switch_model_fn,
 )
 from ..tools import get_tool_registry, ToolRegistry
 from ..tools.fs import BUILTIN_TOOLS as FS_TOOLS
@@ -67,14 +75,14 @@ def _get_or_create_session(session_id: str = "") -> tuple[str, AgentSession]:
     return session_id, _sessions[session_id]
 
 
-# ── API Handlers ───────────────────────────────────────────────────────
+# ── API Handlers (pure functions, called by @app.api or raw routes) ────
 
 def api_chat(
     message: str,
     session_id: str = "",
     image_url: str | None = None,
 ) -> Generator[str, None, None]:
-    """Main chat endpoint — streams events as JSON lines."""
+    """Main chat endpoint — streams events as newline-delimited JSON."""
     if not message or not message.strip():
         yield json.dumps({"type": "error", "error": "Empty message"})
         return
@@ -94,7 +102,7 @@ def api_model_status() -> str:
 
 
 def api_switch_model(model_key: str) -> str:
-    switch_model(model_key)
+    switch_model_fn(model_key)
     return json.dumps({"status": "switching", "model": model_key})
 
 
@@ -237,22 +245,23 @@ def api_get_config() -> str:
 def create_app():
     """Create and return a gradio.Server with custom HTML frontend.
 
-    Uses the Gradio 6.x Server pattern:
-    - @app.api() for backend endpoints (gets queuing + concurrency)
-    - @app.get("/") to serve custom index.html
-    - No gr.Blocks, no hidden Textbox hacks
+    Follows the blog pattern exactly:
+      https://huggingface.co/blog/introducing-gradio-server
+
+    - @app.api(name="...") for backend endpoints (gets Gradio queuing + concurrency)
+    - @app.post("/chat") raw FastAPI StreamingResponse for SSE streaming
+    - @app.get("/") serves index.html from project root
+    - Frontend uses @gradio/client for non-streaming, raw fetch for streaming
     """
-    import gradio as gr
-    from fastapi.responses import HTMLResponse
+    from gradio import Server
 
-    app = gr.Server()
+    app = Server()
 
-    # ── Backend API endpoints (with Gradio queuing) ──
+    # ── Backend API endpoints via @app.api() (Gradio queuing) ─────────
 
-    @app.api(name="chat")
-    def chat(message: str, session_id: str = "", image_url: str = ""):
-        """Stream chat events as newline-delimited JSON."""
-        return api_chat(message, session_id, image_url or None)
+    @app.api(name="get_config")
+    def get_config():
+        return api_get_config()
 
     @app.api(name="model_status")
     def model_status():
@@ -298,24 +307,59 @@ def create_app():
     def reset_session(session_id: str = ""):
         return api_reset_session(session_id)
 
-    @app.api(name="get_config")
-    def get_config():
-        return api_get_config()
+    # ── Streaming chat: raw FastAPI route (SSE) ───────────────────────
 
-    # ── Serve custom HTML frontend ──
+    @app.post("/chat")
+    async def chat_stream(request: Request):
+        """Streaming chat via raw FastAPI — returns newline-delimited JSON."""
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+
+        message = body.get("message", "")
+        session_id = body.get("session_id", "")
+        image_url = body.get("image_url")
+
+        if not message or not message.strip():
+            return StreamingResponse(
+                iter([json.dumps({"type": "error", "error": "Empty message"}) + "\n"]),
+                media_type="text/event-stream",
+                headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+            )
+
+        sid, session = _get_or_create_session(session_id)
+
+        def event_generator():
+            try:
+                for event in session.run(message, session_id=sid, image_url=image_url):
+                    yield json.dumps(event, ensure_ascii=False) + "\n"
+            except Exception as e:
+                logger.error(f"Chat stream error: {e}", exc_info=True)
+                yield json.dumps({"type": "error", "error": str(e)}) + "\n"
+
+        return StreamingResponse(
+            event_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Accel-Buffering": "no",
+                "Connection": "keep-alive",
+            },
+        )
+
+    # ── Serve custom HTML frontend from project root ──────────────────
 
     @app.get("/", response_class=HTMLResponse)
     async def homepage():
-        """Serve the custom SPA frontend."""
-        # Build config JSON to inject
-        config_str = api_get_config()
-
-        html_path = Path(__file__).parent.parent.parent / "static" / "index.html"
+        """Serve the custom SPA frontend — index.html at project root."""
+        html_path = Path(__file__).parent.parent.parent / "index.html"
         if not html_path.exists():
-            return HTMLResponse("<h1>SoniCoder v2</h1><p>index.html not found</p>")
-
-        html = html_path.read_text(encoding="utf-8")
-        html = html.replace("__RUNTIME_CONFIG__ || {}", config_str + " || {}")
-        return HTMLResponse(content=html)
+            return HTMLResponse(
+                "<h1>SoniCoder v2</h1><p>index.html not found at project root</p>",
+                status_code=500,
+            )
+        with open(html_path, "r", encoding="utf-8") as f:
+            return f.read()
 
     return app