Real fix: restore demo.launch() as entrypoint (required for ZeroGPU detection), expose /generate via Gradio's native api_name mechanism instead of a custom FastAPI route

app.py

@@ -1,20 +1,26 @@
 """
 chatPDB inference API — HuggingFace Space (Gradio SDK, ZeroGPU)
 
-Exposes POST /generate (SSE) consumed by the Flask PTY app on the droplet.
-Gradio SDK is required for ZeroGPU (confirmed live 2026-07-23: requesting ZeroGPU hardware for a
-Docker-SDK Space returns "ZeroGPU Spaces only work with Gradio SDK") -- the Gradio UI itself is
-just a minimal landing page.
-
-Real fix (found + fixed 2026-07-23): mounting a custom route via `@demo.app.post(...)` on the
-Blocks object's own `.app` attribute does NOT reliably take effect on HF Spaces -- confirmed live
-against the actual deployed Space: `curl -X POST .../generate` returned 405 with `allow: GET`,
-meaning Gradio's own catch-all SPA route claimed the path instead (Gradio's launch machinery
-appears to reconstruct/finalize its FastAPI app at launch time, after the route was added to the
-earlier `demo.app` reference). Fixed using Gradio's own documented pattern for combining custom
-FastAPI routes with a Gradio UI: build a plain FastAPI `app` first, register routes on it, then
-mount Gradio as a sub-application at a distinct path (routes registered directly on the outer
-`app` are not shadowed by Gradio's own routing, which only applies within its mounted sub-path).
+Exposes a Gradio API endpoint (api_name="generate") consumed by the Flask PTY app on the droplet
+via Gradio's own REST protocol (POST /call/generate -> event_id, then GET /call/generate/<id> for
+an SSE stream) -- NOT a hand-rolled custom FastAPI route.
+
+Real fix history (found + fixed 2026-07-23, in order):
+  1. First attempt added a custom route via `@demo.app.post("/generate")` -- confirmed live via
+     curl that this silently doesn't take effect (405, `allow: GET`); Gradio's own catch-all SPA
+     route claims the path instead.
+  2. Second attempt used `gr.mount_gradio_app()` to mount Gradio under a FastAPI app that owns the
+     real routes -- this DID fix routing, but broke ZeroGPU entirely: the Space failed to start
+     with "No @spaces.GPU function detected during startup". Confirmed via web research (HF forum
+     threads on this exact error) that ZeroGPU's detection hook requires Gradio's own `demo.launch()`
+     to be the actual serving entrypoint -- a custom-FastAPI-primary architecture is not supported,
+     regardless of whether spaces.GPU is imported/used.
+  3. This version: `demo.launch()` is the real entrypoint again (restoring ZeroGPU detection), and
+     the /generate contract is exposed via Gradio's own native API mechanism instead of a custom
+     route -- a hidden Textbox pair wired to a `.click()` handler with `api_name="generate"`, which
+     Gradio automatically exposes as `POST /call/generate` + `GET /call/generate/<event_id>` (SSE).
+     This stays entirely within Gradio's own request-handling pipeline, which is what ZeroGPU's
+     detection actually requires.
 
 Cold-start note: first request after idle downloads the GGUF and allocates the GPU
 (~60-120 s). Subsequent requests within the same GPU lease are fast.
@@ -25,9 +31,6 @@ import json
 
 import gradio as gr
 import spaces
-import uvicorn
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse
 from huggingface_hub import hf_hub_download
 
 REPO_ID = "Dellboy/chatpdb_32b_v1-GGUF"
@@ -51,13 +54,13 @@ def _generate_tokens(
     max_tokens: int,
     temperature: float,
     repeat_penalty: float,
-) -> list[str]:
-    """Run inside the ZeroGPU lease; collect all tokens and return.
+) -> str:
+    """Run inside the ZeroGPU lease; collect all tokens and return as one joined string.
 
     ZeroGPU-decorated functions run in a bounded lease and can't hold a live generator open
-    across the function boundary, so tokens are collected here and streamed out afterward by the
-    /generate route below -- the client sees compute-then-deliver rather than true live
-    token-by-token latency, a real trade-off of the ZeroGPU model.
+    across the function boundary, so tokens are collected here rather than streamed token-by-token
+    -- the client sees compute-then-deliver rather than true live latency, a real trade-off of the
+    ZeroGPU model.
     """
     from llama_cpp import Llama
 
@@ -67,7 +70,7 @@ def _generate_tokens(
         n_gpu_layers=N_GPU_LAYERS,
         verbose=False,
     )
-    tokens: list[str] = []
+    parts: list[str] = []
     for chunk in llm(
         prompt,
         max_tokens=max_tokens,
@@ -77,51 +80,45 @@ def _generate_tokens(
     ):
         tok = chunk["choices"][0]["text"]
         if tok:
-            tokens.append(tok)
-    return tokens
+            parts.append(tok)
+    return "".join(parts)
 
 
-# -- Plain FastAPI app owns the real API routes --
+def _generate_api(prompt: str, max_tokens: int, temperature: float, repeat_penalty: float) -> str:
+    """Thin wrapper: chat_remote.py sends max_tokens/temperature/repeat_penalty as a JSON string
+    packed into one field isn't needed -- Gradio's API takes positional args directly, matching
+    the .click() inputs list below."""
+    return _generate_tokens(prompt, int(max_tokens), float(temperature), float(repeat_penalty))
 
-app = FastAPI(title="chatPDB API")
-
-
-@app.post("/generate")
-async def generate(request: Request):
-    body = await request.json()
-    prompt = body.get("prompt", "")
-    max_tokens = int(body.get("max_tokens", 512))
-    temperature = float(body.get("temperature", 0.15))
-    repeat_penalty = float(body.get("repeat_penalty", 1.15))
-
-    tokens = _generate_tokens(prompt, max_tokens, temperature, repeat_penalty)
-
-    def event_stream():
-        for tok in tokens:
-            yield f"data: {json.dumps({'token': tok})}\n\n"
-        yield "data: [DONE]\n\n"
-
-    return StreamingResponse(event_stream(), media_type="text/event-stream")
-
-
-@app.get("/health")
-async def health():
-    return {"status": "ok"}
-
-
-# -- Gradio UI (minimal -- required for Gradio SDK / ZeroGPU), mounted at a sub-path so it can't
-#    shadow the routes registered directly on `app` above --
 
 with gr.Blocks(title="chatPDB API") as demo:
     gr.Markdown(
         "## 🧬 chatPDB Inference API\n\n"
         "Internal endpoint for [chatpdb.mdeller.com](https://chatpdb.mdeller.com). "
-        "Use `POST /generate` — returns `text/event-stream` of token chunks.\n\n"
+        "Consumed via Gradio's own API: `POST /call/generate` then `GET /call/generate/<event_id>` "
+        "(SSE).\n\n"
         "**Cold start:** first request after idle takes ~60-120 s (GGUF download + GPU alloc)."
     )
 
-app = gr.mount_gradio_app(app, demo, path="/ui")
+    # Hidden inputs/outputs purely to register a real Gradio event with api_name="generate" --
+    # ZeroGPU's startup detection scans Gradio's own event/dependency graph, so the GPU-decorated
+    # function must be reachable through a real .click()/.submit() binding, not just referenced
+    # from a custom route.
+    with gr.Row(visible=False):
+        prompt_in = gr.Textbox()
+        max_tokens_in = gr.Number(value=512)
+        temperature_in = gr.Number(value=0.15)
+        repeat_penalty_in = gr.Number(value=1.15)
+        text_out = gr.Textbox()
+        trigger = gr.Button()
+
+    trigger.click(
+        fn=_generate_api,
+        inputs=[prompt_in, max_tokens_in, temperature_in, repeat_penalty_in],
+        outputs=text_out,
+        api_name="generate",
+    )
 
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.launch()

requirements.txt

@@ -3,4 +3,3 @@ llama-cpp-python
 gradio>=4.0
 spaces
 huggingface_hub
-uvicorn