space: adopt the org's proven NPCverse structure — gradio 6 Server + @app .api + app.launch() (installs ZeroGPU hooks), transformers 5 (compatible with gradio 6; trust_remote_code uses our repo's modeling). Replaces the custom engine.launch+route-surgery that broke the hooks and segfaulted.

README.md

@@ -4,7 +4,7 @@ emoji: 🕯️
 colorFrom: green
 colorTo: gray
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 6.18.0
 python_version: "3.12"
 app_file: space/app.py
 pinned: false

requirements.txt

@@ -1,18 +1,18 @@
-# HF Space (Gradio SDK + ZeroGPU). Inference follows the ZeroGPU docs exactly:
-# bf16 model placed on cuda at module level via .to('cuda') (NOT device_map,
-# NOT bitsandbytes — both fight ZeroGPU's CUDA emulation and were the source of
-# every earlier crash). Measured box: 2TB CPU RAM, 96GB VRAM on xlarge.
-gradio==5.49.1
+# HF Space (Gradio SDK + ZeroGPU). Structure mirrors the org's working
+# NPCverse space: gradio.Server (gradio 6) + @app.api + app.launch(). That
+# needs transformers 5 (gradio 6 forbids huggingface-hub<1.0, which tf<5
+# pins); our checkpoint's auto_map + trust_remote_code makes tf5 use the
+# repo's modeling code regardless. bf16, no bitsandbytes.
+# gradio itself comes from the Space's sdk_version (6.18.0); don't double-pin.
 spaces
 torch==2.10.0
-transformers>=4.57,<5
+transformers>=5
 accelerate
-huggingface_hub>=0.30
+huggingface_hub>=1.2
 textual>=1.0
 rich>=13.0
 pyyaml>=6.0
 httpx>=0.27
-# Nemotron-H hard-imports mamba_ssm's triton kernels; prebuilt wheels for
-# torch 2.10 / cu12 / cp312 (pip's isolated build env can't compile them).
+# Nemotron-H hard-imports mamba_ssm's triton kernels (torch 2.10 / cu12 / cp312).
 https://github.com/state-spaces/mamba/releases/download/v2.3.2.post1/mamba_ssm-2.3.2.post1+cu12torch2.10cxx11abiTRUE-cp312-cp312-linux_x86_64.whl
 https://github.com/Dao-AILab/causal-conv1d/releases/download/v1.6.2.post1/causal_conv1d-1.6.2.post1+cu12torch2.10cxx11abiTRUE-cp312-cp312-linux_x86_64.whl

space/app.py

@@ -1,27 +1,26 @@
-"""SCRYPT on the web — the finetuned Warden on ZeroGPU, done the documented way.
+"""SCRYPT on the web — the finetuned Warden on ZeroGPU.
 
-Hard-won lesson: every earlier crash came from bitsandbytes + device_map="cuda"
-fighting ZeroGPU's CUDA emulation. The blessed pattern (verified against a live
-probe on this box: 2TB CPU RAM, RTX Pro 6000 Blackwell, 96GB on xlarge) is:
+Structured to match how working ZeroGPU spaces with a custom frontend actually
+do it (e.g. the org's own NPCverse): a `gradio.Server` (which IS a FastAPI app)
+hosts our custom HTML/websocket routes AND exposes GPU inference through
+`@app.api(...)`, and the whole thing is started with gradio's own
+`app.launch(...)`. That launch is what installs ZeroGPU's hooks + queue — the
+piece my earlier `engine.launch(prevent_thread_lock=True)` + manual route
+surgery skipped, which is why every GPU call segfaulted in CUDA init.
 
-  * load the model in bf16 and place it with .to('cuda') AT MODULE LEVEL
-    (ZeroGPU emulates CUDA outside @spaces.GPU, then migrates at call time);
-  * NO device_map, NO bitsandbytes, NO lazy-load-inside-the-worker;
-  * the @spaces.GPU function can be called straight from a FastAPI route via
-    run_in_threadpool (the probe ran in 1.0s that way).
-
-Gradio is the engine room, not the face: it launches the server (and arms the
-ZeroGPU startup handshake), then we transplant our own routes onto its FastAPI
-so the custom CRT page and the raw PTY websocket win. Game subprocesses reach
-the Warden through the existing `api` backend pointed at our loopback /v1.
+The model is bf16, placed on cuda at module level with `.to('cuda')` (NO
+device_map="cuda", NO bitsandbytes — both fight ZeroGPU). The @spaces.GPU
+function is only ever entered through Gradio (via the @app.api handler, reached
+from the loopback /v1 shim with gradio_client), never a bare threadpool call.
 
   GET  /            CRT landing page
   GET  /api/status  is the Warden loaded?
-  GET  /api/probe   ask the live Warden one line (verify generation)
+  GET  /api/probe   ask the live Warden one line
   GET  /api/whisper scripted teaser
   GET  /play        xterm.js terminal
   WS   /pty         per-visitor game subprocess
-  POST /v1/chat/completions  loopback OpenAI endpoint (game -> @spaces.GPU)
+  POST /v1/chat/completions  loopback OpenAI shim for the game's `api` backend
+  api  warden_generate        the @spaces.GPU endpoint, in Gradio's context
 """
 
 from __future__ import annotations
@@ -31,7 +30,6 @@ import json
 import os
 import random
 import secrets
-import sys
 import tempfile
 from pathlib import Path
 
@@ -41,10 +39,11 @@ try:
 except ImportError:
     spaces = None
 
-from fastapi import APIRouter, Request, WebSocket, WebSocketDisconnect
+from fastapi import Request, WebSocket, WebSocketDisconnect
 from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from starlette.concurrency import run_in_threadpool
+from gradio import Server
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 STATIC = Path(__file__).parent / "static"
@@ -56,32 +55,23 @@ tok = None
 model = None
 WARDEN_ERR = "spaces package not present (not on a ZeroGPU Space)"
 
-
-def _install_mamba_kernels() -> None:
-    """Nemotron-H hard-imports mamba_ssm's triton kernels. The wheels are in
-    requirements.txt; this just confirms they imported (CPU-only, no CUDA)."""
-    from mamba_ssm.ops.triton.layernorm_gated import rmsnorm_fn  # noqa: F401
-
-
 if spaces is not None:
     try:
-        _install_mamba_kernels()
+        from mamba_ssm.ops.triton.layernorm_gated import rmsnorm_fn  # noqa: F401
         import torch
         from transformers import AutoModelForCausalLM, AutoTokenizer
 
         tok = AutoTokenizer.from_pretrained(WARDEN_REPO, trust_remote_code=True)
-        # bf16, no device_map. .to('cuda') at module level is intercepted by
-        # ZeroGPU's emulation and migrated to the real GPU per @spaces.GPU call.
         model = AutoModelForCausalLM.from_pretrained(
             WARDEN_REPO,
             torch_dtype=torch.bfloat16,
             trust_remote_code=True,
             low_cpu_mem_usage=True,
         )
-        model.to("cuda")
+        model.to("cuda")  # intercepted by ZeroGPU emulation; migrated per call
         model.eval()
         WARDEN_ERR = ""
-    except Exception as err:  # the game survives without the model (scripted)
+    except Exception as err:
         import traceback
 
         traceback.print_exc()
@@ -91,9 +81,6 @@ WARDEN_READY = not WARDEN_ERR
 
 
 def _generate_impl(messages, max_tokens, temperature, enable_thinking):
-    """Blocking generate -> full text. Single short line, so no streaming
-    machinery (a thread + streamer across the ZeroGPU fork hangs); the game's
-    typewriter reveals it client-side."""
     import torch
 
     inputs = tok.apply_chat_template(
@@ -113,16 +100,15 @@ def _generate_impl(messages, max_tokens, temperature, enable_thinking):
     return tok.decode(out[0, inputs.shape[1]:], skip_special_tokens=True)
 
 
-# bf16 30B (~60GB) needs the 96GB xlarge slice; duration covers the first
-# call's CPU->GPU migration. The probe proved a direct run_in_threadpool call
-# into a @spaces.GPU function works on this box.
+# bf16 30B (~60GB) needs the 96GB xlarge slice; duration covers first-call
+# migration. ONLY entered through Gradio (the @app.api handler below).
 if spaces is not None:
     warden_gpu = spaces.GPU(size="xlarge", duration=120)(_generate_impl)
 else:
     warden_gpu = _generate_impl
 
 
-# ----------------------------------------------------------------- the surface
+# ----------------------------------------------------------------- the app
 
 WHISPERS = [
     "Another process wakes in my machine. Show me what you are.",
@@ -135,15 +121,19 @@ WHISPERS = [
     "Trespasser. The door was open because nothing has ever made it out.",
 ]
 
-router = APIRouter()
+app = Server(title="SCRYPT")
+
 
-# The ONLY correct way to drive a @spaces.GPU function: through Gradio's queue.
-# A bare run_in_threadpool(warden_gpu) inits CUDA in a worker thread and
-# segfaults. So we register warden_gpu as a Gradio API endpoint (see gr.api in
-# the engine room) and reach it over localhost with gradio_client — the call
-# then executes inside Gradio's ZeroGPU-hooked context, and our own thread only
-# does HTTP (no CUDA). This mirrors how the org's NPCverse space drives GPU
-# work through gradio.Server's api rather than raw FastAPI routes.
+@app.api(name="warden_generate")
+def warden_generate(payload_json: str) -> str:
+    """The @spaces.GPU entry point, in Gradio's hooked context. Reached over
+    localhost by the /v1 shim via gradio_client. Plain JSON in, text out."""
+    p = json.loads(payload_json)
+    return warden_gpu(p["messages"], p["max_tokens"], p["temperature"], p["thinking"])
+
+
+# The loopback OpenAI shim hits warden_generate through Gradio, so the GPU call
+# executes in Gradio's context (our own thread only does localhost HTTP).
 _gradio_client = None
 
 
@@ -162,17 +152,16 @@ def _gradio_generate(messages, max_tokens, temperature, thinking) -> str:
     return _gradio_client.predict(payload, api_name="/warden_generate")
 
 
-@router.get("/api/status")
+@app.get("/api/status")
 def status() -> dict:
     return {
         "warden_ready": WARDEN_READY,
         "warden_state": "ready" if WARDEN_READY else WARDEN_ERR,
         "model": WARDEN_REPO,
-        "engine": "transformers/bf16 @ ZeroGPU xlarge",
     }
 
 
-@router.get("/api/probe")
+@app.get("/api/probe")
 async def probe(q: str = "A new process woke up in your machine. Greet it in one short line, in voice.") -> dict:
     import time
 
@@ -190,10 +179,8 @@ async def probe(q: str = "A new process woke up in your machine. Greet it in one
         return {"ok": False, "error": f"{type(err).__name__}: {err}"}
 
 
-@router.post("/v1/chat/completions")
+@app.post("/v1/chat/completions")
 async def chat_completions(request: Request):
-    """Loopback OpenAI endpoint for the game's `api` backend. Per-boot bearer
-    so only our own subprocesses drive the GPU."""
     if request.headers.get("authorization") != f"Bearer {INTERNAL_KEY}":
         return JSONResponse({"error": "unauthorized"}, status_code=401)
     if not WARDEN_READY:
@@ -221,17 +208,17 @@ async def chat_completions(request: Request):
     return StreamingResponse(sse(), media_type="text/event-stream")
 
 
-@router.get("/api/whisper")
+@app.get("/api/whisper")
 def whisper() -> dict:
     return {"line": random.choice(WHISPERS)}
 
 
-@router.get("/")
+@app.get("/")
 def landing() -> FileResponse:
     return FileResponse(STATIC / "index.html")
 
 
-@router.get("/play")
+@app.get("/play")
 def play() -> FileResponse:
     return FileResponse(STATIC / "play.html")
 
@@ -270,7 +257,7 @@ async def _pump_pty_to_ws(master_fd: int, ws: WebSocket) -> None:
         pass
 
 
-@router.websocket("/pty")
+@app.websocket("/pty")
 async def pty_bridge(ws: WebSocket) -> None:
     import fcntl
     import pty
@@ -317,61 +304,10 @@ async def pty_bridge(ws: WebSocket) -> None:
         os.close(master_fd)
 
 
-# ------------------------------------------------------------ the engine room
-
-import gradio as gr  # noqa: E402
-
-
-def _api_generate(payload_json: str) -> str:
-    """Gradio API endpoint -> the GPU. Reached over localhost by the /v1 shim
-    via gradio_client, so it runs inside Gradio's ZeroGPU-hooked context (the
-    one place a @spaces.GPU call is safe). Takes/returns plain JSON-able types."""
-    p = json.loads(payload_json)
-    return warden_gpu(p["messages"], p["max_tokens"], p["temperature"], p["thinking"])
-
-
-def _probe_ui(text: str) -> str:
-    if not WARDEN_READY:
-        return f"warden offline: {WARDEN_ERR}"
-    try:
-        return warden_gpu([{"role": "user", "content": text}], 80, 0.6, False)
-    except Exception as err:
-        return f"generation failed: {type(err).__name__}: {err}"
-
-
-with gr.Blocks(title="SCRYPT engine room") as engine:
-    gr.Markdown(
-        "# SCRYPT engine room\n\n"
-        f"model: `{WARDEN_REPO}`\n\n"
-        f"status: {'**ready**' if WARDEN_READY else f'offline — {WARDEN_ERR}'}\n\n"
-        "The game lives at [/](/)."
-    )
-    box = gr.Textbox(label="say something to the Warden")
-    out = gr.Textbox(label="the Warden")
-    box.submit(_probe_ui, box, out)
-    # The loopback inference path: /v1 -> gradio_client -> this -> warden_gpu,
-    # so the GPU call executes in Gradio's hooked context.
-    gr.api(_api_generate, api_name="warden_generate")
+app.mount("/static", StaticFiles(directory=STATIC), name="static")
 
 
 if __name__ == "__main__":
-    fastapi_app, _, _ = engine.launch(
-        prevent_thread_lock=True,
-        server_name="0.0.0.0",
-        server_port=7860,
-        ssr_mode=False,
-        quiet=True,
-    )
-    fastapi_app.include_router(router)
-    fastapi_app.mount("/static", StaticFiles(directory=STATIC), name="static")
-    # Move our routes (incl. the /static mount) ahead of gradio's catch-all.
-    names = {
-        "status", "probe", "chat_completions", "whisper",
-        "landing", "play", "pty_bridge", "static",
-    }
-    our = [r for r in fastapi_app.router.routes if getattr(r, "name", "") in names]
-    for r in our:
-        fastapi_app.router.routes.remove(r)
-    fastapi_app.router.routes[0:0] = our
-
-    engine.block_thread()
+    # gradio's own launch — installs the ZeroGPU hooks + queue and serves our
+    # custom routes. NOT uvicorn.run, NOT prevent_thread_lock + route surgery.
+    app.launch(server_name="0.0.0.0", server_port=7860, show_error=True)