strip: local-only backends; remove diagnostic endpoints

arcana/gpu_models.py

@@ -4,20 +4,15 @@ Models load LAZILY and cache process-wide. They MUST be constructed inside an
 ``@spaces.GPU`` context (the only time the GPU is attached on ZeroGPU); nothing
 here runs at import, and CUDA must not initialise at import (the process forks).
 
-HYBRID LLM split (disk is ~1.5TB free, so we can cache several models; the limit
-is the 48GB VRAM PER @spaces.GPU CALL, and these are never resident together):
-  * MAPPING (json) → a small dense model (8B Llama-Nemotron): reliable structured
-    JSON, fast, ~5GB. Runs in the build call alongside FLUX.
-  * READING (prose) → a larger model (Nemotron-3-Nano-30B by default on capable
-    spaces): richer readings. Runs alone in the reading call (~18GB).
-Both env-overridable so a space can keep the 8B for reading too (set READ=MAP).
+ONE LLM (Qwen3-14B) serves all three roles (mapping, scribe, reading); the work is
+fanned across separate @spaces.GPU calls (and concurrent GPU slots) rather than
+across different models. The image model (FLUX.2-klein) is the only other model.
 
 Hard-won ZeroGPU facts (June 2026, RTX PRO 6000 Blackwell / CUDA 13 / torch cu130):
   * llama-cpp-python must be the cu130 wheel; preload the CUDA-13 runtime libs
     (site-packages/nvidia/cu13/lib) RTLD_GLOBAL before importing llama_cpp.
-  * Nemotron-3 (ChatML) reasons unless the assistant turn is seeded with an empty
-    <think></think> block — so for it we hand-build the prompt + create_completion.
-    Llama-Nemotron (Llama-3 template) just needs "detailed thinking off" in system.
+  * Qwen3 is a "thinking" model — we append "/no_think" for a direct answer; JSON is
+    grammar-constrained via response_format (see _chat).
 """
 from __future__ import annotations
 
@@ -40,19 +35,10 @@ except Exception:
     pass
 
 # ---- model selection (env-overridable) ------------------------------------
-# SINGLE MODEL: Qwen3-14B for BOTH mapping and reading. We dropped Nemotron-3-30B
-# (and the Nemotron prize): as a 3.5B-ACTIVE MoE at Q4 it was too literal-minded —
-# it emitted tool calls instead of JSON, refused "divination", and went meta in the
-# reader. Qwen3-14B is the same family as the original endpoint version (Qwen3-32B)
-# at a safely ≤32B size; a plain capable instruct/reasoning model. It's a "thinking"
-# model, so we append "/no_think" (exactly as the old endpoint build did) for direct
-# output; JSON mapping is still grammar-constrained (response_format). One model,
-# warmed once. Mapping (design), loremaster and reading run in separate @spaces.GPU
-# calls; lore + FLUX run on two CONCURRENT GPUs so they never share 48GB.
-_DEF_8B = ("bartowski/nvidia_Llama-3.1-Nemotron-Nano-8B-v1-GGUF",
-           "nvidia_Llama-3.1-Nemotron-Nano-8B-v1-Q4_K_M.gguf")
-_DEF_30B = ("unsloth/Nemotron-3-Nano-30B-A3B-GGUF",
-            "Nemotron-3-Nano-30B-A3B-Q4_K_M.gguf")
+# ONE open ≤32B LLM (Qwen3-14B, Apache-2.0) for all three roles: mapping, scribe,
+# reading. A "thinking" model — _chat appends "/no_think" for a direct answer; JSON
+# is grammar-constrained (response_format). The roles run in separate @spaces.GPU
+# calls (and the scribe/painter fan across concurrent GPU slots).
 _DEF_QWEN14 = ("unsloth/Qwen3-14B-GGUF", "Qwen3-14B-Q4_K_M.gguf")
 MAP_REPO = os.environ.get("LOCAL_MAP_REPO", _DEF_QWEN14[0])
 MAP_FILE = os.environ.get("LOCAL_MAP_FILE", _DEF_QWEN14[1])
@@ -62,10 +48,6 @@ READ_FILE = os.environ.get("LOCAL_READ_FILE", _DEF_QWEN14[1])
 READ_N_CTX = int(os.environ.get("LOCAL_READ_N_CTX", "16384"))
 
 # FLUX.2-klein-9B (distilled → 4 steps, guidance_scale=1.0) run LOCALLY via diffusers.
-# Back to FLUX.2: the religious-imagery / quality drop we'd blamed on klein was really
-# Nemotron's weak art prompts — FLUX.1 had the same bias on RWS-styled prompts. With
-# Qwen3-14B art prompts + the no-religious guard in imagegen._style, klein is the better
-# (newer, sharper) model. Gated but already accepted on this account.
 IMAGE_MODEL = os.environ.get("LOCAL_IMAGE_MODEL", "black-forest-labs/FLUX.2-klein-9B")
 
 _models: dict = {}
@@ -99,9 +81,8 @@ def _get_llama(repo: str, fname: str, n_ctx: int):
     worker per call and only migrates torch-registered tensors; a llama.cpp context
     (C++/GPU pointers) isn't picklable and module-scope warmup doesn't carry. So the
     model loads in-worker on first call; warm workers keep it resident (2nd+ call
-    fast). We just tune the construct: flash-attention (Llama-arch only — the 30B
-    hybrid-Mamba doesn't support FA) + a big n_batch to speed long-prompt eval (the
-    designer's few-shot mapping prompt)."""
+    fast). We tune the construct: flash-attention + a big n_batch to speed long-prompt
+    eval (the designer's few-shot mapping prompt)."""
     if fname not in _models:
         import time as _t
         from .timing import record
@@ -111,9 +92,7 @@ def _get_llama(repo: str, fname: str, n_ctx: int):
         from llama_cpp import Llama
         path = hf_hub_download(repo, fname, token=os.environ.get("HF_TOKEN"))
         kwargs = dict(model_path=path, n_gpu_layers=-1, n_ctx=n_ctx,
-                      n_batch=2048, verbose=False)
-        if not _is_nemotron3(fname):  # FA works for Llama/Qwen arch, not the Mamba hybrid
-            kwargs["flash_attn"] = True
+                      n_batch=2048, flash_attn=True, verbose=False)
         try:
             _models[fname] = Llama(**kwargs)
         except Exception:
@@ -123,11 +102,6 @@ def _get_llama(repo: str, fname: str, n_ctx: int):
     return _models[fname]
 
 
-def _is_nemotron3(fname: str) -> bool:
-    f = fname.lower()
-    return "30b" in f or "nemotron-3-nano-3" in f
-
-
 def _is_qwen3(fname: str) -> bool:
     return "qwen3" in fname.lower()
 
@@ -149,40 +123,6 @@ def _chat(llm, fname: str, system: str, user: str, max_tokens: int,
     return (out["choices"][0]["message"]["content"] or "").strip()
 
 
-def _last_balanced_json(text: str) -> str:
-    """Return the LAST top-level {...} block in text (the final answer after any
-    reasoning), else the whole text. Lets a reasoning model think first, then we
-    take the JSON it emits at the end."""
-    objs, depth, start, in_str, esc = [], 0, None, False, False
-    for i, c in enumerate(text):
-        if in_str:
-            if esc: esc = False
-            elif c == "\\": esc = True
-            elif c == '"': in_str = False
-            continue
-        if c == '"': in_str = True
-        elif c == "{":
-            if depth == 0: start = i
-            depth += 1
-        elif c == "}":
-            if depth > 0:
-                depth -= 1
-                if depth == 0 and start is not None:
-                    objs.append(text[start:i + 1]); start = None
-    return objs[-1] if objs else text
-
-
-def _suppress_gen(llm, system: str, user: str, max_tokens: int, temperature: float) -> str:
-    """Nemotron-3 ChatML with an empty <think></think> seed → clean, non-reasoning
-    prose (fast). Used for readings."""
-    prompt = (f"<|im_start|>system\n{system}<|im_end|>\n"
-              f"<|im_start|>user\n{user}<|im_end|>\n"
-              f"<|im_start|>assistant\n<think></think>\n")
-    out = llm.create_completion(prompt=prompt, max_tokens=max_tokens,
-                                temperature=temperature, stop=["<|im_end|>"])
-    return (out["choices"][0]["text"] or "").strip()
-
-
 def llama_map(system: str, user: str, max_tokens: int = 12000,
               temperature: float = 0.6, schema: dict | None = None) -> str:
     """Structured JSON generation (mapping AND loremaster). When a JSON-SCHEMA is