feat: add INFERENCE_BACKEND provider switch, Space stays as API

app.py

@@ -38,6 +38,7 @@ import spaces  # noqa: E402
 import gradio as gr  # noqa: E402
 from huggingface_hub import snapshot_download  # noqa: E402
 from inference_demo import initialize, evaluate  # noqa: E402
+from backend.inference_backend import VastAIBackend, ZeroGPUBackend, get_backend_kind  # noqa: E402
 
 REPO_ID = "radar-generalist/RADAR"
 CHECKPOINT_NAME = "checkpoint_radar_pretrain.pth"
@@ -95,7 +96,12 @@ def _score_case(tmpdir, outdir):
 
 
 def diagnose(ct_files):
-    """Gradio entry (CPU): stage uploads, then score under a short GPU reservation."""
+    """Gradio entry (CPU): stage uploads, then score on the active backend."""
+    kind = get_backend_kind()
+    if kind not in ("zerogpu", "vastai"):
+        raise gr.Error("unknown INFERENCE_BACKEND")
+    if kind == "vastai":
+        VastAIBackend().ensure_available()  # fail before mkdtemp/staging
     items = ct_files if isinstance(ct_files, list) else [ct_files]
     paths = [p if isinstance(p, str) else p.name for p in items]
     tmpdir = tempfile.mkdtemp(prefix="radar_case_")
@@ -128,7 +134,9 @@ def diagnose(ct_files):
                 _series_to_nifti(staged, tmpdir)
             finally:
                 shutil.rmtree(staged, ignore_errors=True)
-        return _score_case(tmpdir, outdir)
+        if kind == "vastai":
+            return VastAIBackend().score_case(tmpdir, outdir)
+        return ZeroGPUBackend(_score_case).score_case(tmpdir, outdir)
     finally:
         shutil.rmtree(tmpdir, ignore_errors=True)
         shutil.rmtree(outdir, ignore_errors=True)
@@ -147,8 +155,10 @@ demo = gr.Interface(
     description=(
         "Expert-level generalist AI for contrast-enhanced abdominal CT "
         "(18 structures, 146 findings). Non-commercial research demo "
-        "(CC BY-NC-SA 4.0); assistance tool, not a diagnosis."
+        "(CC BY-NC-SA 4.0); assistance tool, not a diagnosis. "
+        "Full UI: https://radar-ct.pages.dev — this Space remains as API."
     ),
+    api_name="diagnose",
 )
 
 if __name__ == "__main__":

backend/inference_backend.py

@@ -0,0 +1,70 @@
+"""Provider switch for RADAR scoring backends.
+
+ZeroGPU remains the active backend; Vast.ai is a stub holding config fields
+until a Serverless endpoint is provisioned (see backend/vastai/). Frontend
+code branches on the same kind strings ("zerogpu" | "vastai").
+
+Import cost: stdlib only. Importing this module must never pull torch,
+CUDA, or app state — ZeroGPUBackend resolves app._score_case lazily.
+"""
+
+import os
+from typing import Protocol
+
+
+class InferenceBackend(Protocol):
+    def score_case(self, tmpdir: str, outdir: str) -> tuple[dict, object]:
+        """Score one staged case; returns (scores dict, findings DataFrame)."""
+        ...
+
+
+def get_backend_kind() -> str:
+    """Active backend from env; unknown values are validated by callers."""
+    return (os.getenv("INFERENCE_BACKEND", "zerogpu").strip().lower() or "zerogpu")
+
+
+class ZeroGPUBackend:
+    """Active backend: delegates to app._score_case (the @spaces.GPU step).
+
+    score_fn is injected by app.diagnose so this module never imports app
+    at load time (avoids a circular import and keeps CUDA init in app).
+    """
+
+    def __init__(self, score_fn=None):
+        self._score_fn = score_fn
+
+    def score_case(self, tmpdir: str, outdir: str) -> tuple[dict, object]:
+        fn = self._score_fn
+        if fn is None:  # pragma: no cover — production path always injects
+            from app import _score_case as fn
+            self._score_fn = fn
+        return fn(tmpdir, outdir)
+
+
+class VastAIBackend:
+    """Future Vast.ai Serverless backend — not enabled yet.
+
+    Holds the config surface the later cutover needs; score_case fails fast
+    so a misconfigured INFERENCE_BACKEND=vastai can never silently hang.
+    Real key lives server-side in VAST_API_KEY env, never in frontend code.
+    """
+
+    NOT_ENABLED = "Vast.ai backend not enabled: set INFERENCE_BACKEND=zerogpu"
+
+    def __init__(
+        self,
+        endpoint: str = "",
+        api_key_env: str = "VAST_API_KEY",
+    ):
+        self.endpoint = endpoint or os.getenv("VAST_ENDPOINT", "")
+        self.api_key_env = api_key_env
+
+    def ensure_available(self) -> None:
+        """Fail fast before any staging when this backend is selected."""
+        import gradio as gr
+
+        raise gr.Error(self.NOT_ENABLED)
+
+    def score_case(self, tmpdir: str, outdir: str) -> tuple[dict, object]:
+        self.ensure_available()
+        raise RuntimeError("unreachable: Vast.ai backend is not enabled")