Sync from GitHub 50c0a1f

README.md

@@ -13,7 +13,7 @@ app_file: app.py
 pinned: false
 preload_from_hub:
   - nvidia/nemotron-colembed-vl-4b-v2
-  - openbmb/MiniCPM5-1B
+  - openbmb/MiniCPM4.1-8B
   - openbmb/MiniCPM-V-4_5
   - nvidia/llama-nemotron-embed-vl-1b-v2
 license: mit

core/constants.py

@@ -45,20 +45,45 @@ MINICPM_AGENT_REVISION = os.environ.get("MINICPM_AGENT_REVISION", "") or None
 
 # Selectable agent brains, offered in the UI settings panel. ONE model is meant
 # to be resident in VRAM at a time — switching evicts the previous and loads the
-# next (models/minicpm_agent.use_model). NOTE: evicting the FIRST/default brain
-# frees nothing — it's loaded at import (ZeroGPU emulation phase) and materialized
-# into the forked GPU worker, where empty_cache() can't reclaim it; only a brain
-# that was itself switched in at runtime frees on eviction. So a switched-in brain
-# must fit in the headroom ABOVE the resident set + stuck default (~15 GiB free on
-# the 48 GiB `large` slice — see core/vram.py). That's why the 8B brains were
-# dropped (they need ~16 GiB) and the largest option here is 4B.
+# next (models/minicpm_agent.use_model). NOTE: the FIRST/default brain is loaded at
+# import (ZeroGPU emulation phase) and materialized into the forked GPU worker,
+# where empty_cache() can't reclaim it — it stays stuck for the process. A brain
+# SWITCHED IN at runtime must fit the headroom ABOVE the resident set
+# (VLM+ColEmbed+embedder) + that stuck default (~15 GiB free on the 48 GiB `large`
+# slice — see core/vram.py).
+#
+# The default is MiniCPM4.1-8B at int8 (~8.5 GiB via bitsandbytes). As the LONE
+# stuck brain it REPLACES the old 1B default (it does not stack on it), so the
+# resident set + one ~8.5 GiB brain still leaves room for the grounding spike — the
+# same footprint class as MiniCPM3-4B, which was VRAM-vetted to fit. (bf16 8B at
+# ~16 GiB still does NOT fit; int8 is what makes the 8B deployable as the default.)
+# Caveat: with an ~8.5 GiB default already stuck, switching ANOTHER 4-8 GiB brain
+# in at runtime for a UI A/B is tight and may OOM at grounding — the default path
+# is fine.
 # Each loads as an AutoModelForCausalLM; `trust_remote_code` (default False) flags
-# the ones that ship custom modeling code (MiniCPM3-4B). `thinking` flags whether
-# the chat template accepts enable_thinking (Qwen3 and MiniCPM5 do — tool routing
-# passes it False; MiniCPM3 does not). The FIRST entry is the default at boot and
-# tracks the MINICPM_AGENT_MODEL_ID/REVISION env overrides, so existing config
-# still applies. Only one is resident at a time, well under the params budget.
+# the ones that ship custom modeling code (MiniCPM3 / MiniCPM4.1). `thinking` flags
+# whether the chat template accepts enable_thinking (Qwen3, MiniCPM5, MiniCPM4.1 do
+# — tool routing passes it False; MiniCPM3 does not). int8/4bit brains need
+# bitsandbytes (requirements.txt). The FIRST entry is the default at boot; the
+# minicpm5-1b entry stays selectable and still tracks the MINICPM_AGENT_MODEL_ID/
+# REVISION env overrides. Only one brain is resident at a time.
 AGENT_MODELS = [
+    {
+        "key": "minicpm4.1-8b-8bit",
+        "label": "MiniCPM4.1 8B (8-bit)",
+        "model_id": "openbmb/MiniCPM4.1-8B",
+        "revision": None,
+        # DEFAULT brain. Hybrid-reasoning 8B at int8 (~8.5 GiB) — the best
+        # deployable eval config (0.85 tool / 0.91 args; with the v3 prompt it also
+        # recovers half the coincidence fix). trust_remote_code custom modeling
+        # (sparse "InfLLM v2" attention); runs clean on current transformers,
+        # unlike MiniCPM3-4B. Quantized weights load straight onto the GPU, so
+        # device_map is set (skips the host→device .to copy).
+        "thinking": True,
+        "trust_remote_code": True,
+        "quantization": "8bit",
+        "device_map": {"": 0},
+    },
     {
         "key": "minicpm5-1b",
         "label": "MiniCPM5 1B",
@@ -80,6 +105,17 @@ AGENT_MODELS = [
         "revision": None,
         "thinking": True,
     },
+    {
+        "key": "qwen3-4b",
+        "label": "Qwen3 4B",
+        "model_id": "Qwen/Qwen3-4B",
+        "revision": None,
+        # Native Qwen3 arch (no trust_remote_code → immune to the custom-modeling
+        # rot that breaks MiniCPM3-4B on current transformers). ~4B / ~8.1 GiB bf16,
+        # same footprint class as MiniCPM3-4B, which was VRAM-vetted to fit; routing
+        # passes enable_thinking=False.
+        "thinking": True,
+    },
     {
         "key": "minicpm3-4b",
         "label": "MiniCPM3 4B",
@@ -96,6 +132,35 @@ AGENT_MODELS = [
         # switch time with ~5 GiB to spare after the grounding spike. The 8B (16
         # GiB) didn't fit — see core/vram.py / the find-turn VRAM logs.
     },
+    {
+        "key": "minicpm4.1-8b",
+        "label": "MiniCPM4.1 8B",
+        "model_id": "openbmb/MiniCPM4.1-8B",
+        "revision": None,
+        # Hybrid-reasoning 8B (enable_thinking supported; routing passes it False).
+        # trust_remote_code custom modeling (sparse "InfLLM v2" attention) — same
+        # rot risk that broke MiniCPM3-4B on current transformers; pin a reviewed
+        # commit for any real use. NOTE: 8B / ~16 GiB bf16 does NOT fit the
+        # production find turn (the 8B didn't fit — VRAM logs); benchmarkable in
+        # THIS eval (brain-only load) to gauge the quality ceiling, but shipping it
+        # needs quantization (4-bit ~5-6 GiB) + a coexistence VRAM check.
+        "thinking": True,
+        "trust_remote_code": True,
+    },
+    {
+        "key": "minicpm4.1-8b-4bit",
+        "label": "MiniCPM4.1 8B (4-bit)",
+        "model_id": "openbmb/MiniCPM4.1-8B",
+        "revision": None,
+        "thinking": True,
+        "trust_remote_code": True,
+        # bitsandbytes nf4 (~5-6 GiB vs ~16 GiB bf16) to fit the 8B into the
+        # find-turn VRAM budget; quantized weights load straight onto the GPU, so
+        # device_map is set (skips the host→device .to copy). The question this
+        # answers: does 4-bit hold the bf16 8B's quality (0.87/0.86)?
+        "quantization": "4bit",
+        "device_map": {"": 0},
+    },
 ]
 DEFAULT_AGENT_MODEL = AGENT_MODELS[0]["key"]
 # A tool-call decision is short JSON; a rerank reply is a single number. 96 was

frontend/index.html

@@ -261,11 +261,6 @@
           p. <span x-text="viewPage"></span><span class="text-brand-400 font-medium"> / <span x-text="docPages"></span></span>
         </div>
         <div class="flex-1 min-w-0 text-[12px] text-brand-500/90 truncate text-right pr-1" x-text="sectionTitle(viewPage)"></div>
-        <button @click="spread=!spread" :aria-pressed="spread" aria-label="Two-page view" title="Two-page view"
-          class="grid place-items-center w-11 h-11 rounded-xl transition"
-          :class="spread ? 'text-brand-700 bg-brand-100' : 'text-brand-600 hover:bg-brand-100'">
-          <i data-lucide="book-open" class="w-5 h-5"></i>
-        </button>
         <button x-show="navStack.length" @click="goBack()" aria-label="Back" title="Back to previous spot"
           class="grid place-items-center w-11 h-11 rounded-xl text-brand-600 hover:bg-brand-100 transition">
           <i data-lucide="undo-2" class="w-5 h-5"></i>
@@ -273,8 +268,8 @@
       </div>
 
       <!-- the page(s): a book-style spread — the active page plus the next one
-           for context (toggle to single with the book button). Each slot is a
-           full-height flex column; the image fits the slot's HEIGHT and (in
+           for context (always two pages, except on the last page). Each slot is
+           a full-height flex column; the image fits the slot's HEIGHT and (in
            spread) at most half the width, so both facing pages stay fully
            visible without blowing up. img + svg are stacked in one grid cell
            and both carry the page's aspect-ratio + max constraints, so they

models/minicpm_agent.py

@@ -88,6 +88,10 @@ SYSTEM_PROMPT = (
     'verb they use ("find", "search", "show", "where is", "circle") — if it is on '
     "the page in front of you, you point at it; you do NOT search for a better "
     "page, and you do NOT circle a different component than the one asked for.\n"
+    "If instead they asked to SEE or SHOW a whole diagram, overview, or components "
+    "view (not one specific part) and it is already on the screen, the PAGE ITSELF "
+    "is the answer → reply done with a brief confirmation; do NOT circle one "
+    "component out of a diagram they asked to see in full.\n"
     "2. If it is NOT in the current page text, it is not on screen. Then:\n"
     "   - A chapter, system, or section named by topic, or any part / procedure / "
     'spec you cannot see ("go to the cooling system", "engine oil capacity", '
@@ -218,9 +222,14 @@ def search_result_message(request: str, page: int, text: str, stuck: bool) -> st
             "- Only if it is truly not in this manual, use done."
         )
     return body + (
-        f"The mechanic asked for: {request!r}. First, does THIS page show it — the "
-        "part, or the line/value that answers it (it counts even when named inside "
-        "a figure or diagram description)? If so, circle it now — set \"target\" to "
+        f"The mechanic asked for: {request!r}. First, is THIS the right page? Check "
+        "the title/section at the top: if the page is about a DIFFERENT system than "
+        'they asked about — a part that merely shares a word (a "gear" inside a '
+        "fuel-system actuator is NOT a transmission gear) — it is the WRONG page, "
+        "so do NOT circle; search again with a more specific query. If it IS the "
+        "right page and shows the part, or the line/value that answers it (it "
+        "counts even when named inside a figure or diagram description), circle it "
+        'now — set "target" to '
         f"a part name or the exact words printed on p.{page} (copy them from the "
         "page text above), NOT the mechanic's question: "
         '{"tool": "circle", "target": "<exact printed words for the part/value>", '
@@ -319,6 +328,25 @@ def use_model(key: str | None = None) -> str:
     device_map = spec.get("device_map")
     if device_map is not None:
         load_kwargs["device_map"] = device_map
+    # A spec can request on-the-fly bitsandbytes quantization (e.g. "4bit" to fit
+    # an 8B brain into the find-turn VRAM budget). Quantized weights are placed on
+    # the GPU at load time, so such a spec must also set device_map (skips the
+    # .to("cuda") below). bitsandbytes is imported lazily so non-quantized brains
+    # — and the production image, which omits it — never touch it.
+    quant = spec.get("quantization")
+    if quant in ("4bit", "8bit"):
+        from transformers import BitsAndBytesConfig
+
+        load_kwargs["quantization_config"] = (
+            BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.bfloat16,
+                bnb_4bit_use_double_quant=True,
+            )
+            if quant == "4bit"
+            else BitsAndBytesConfig(load_in_8bit=True)
+        )
     model = AutoModelForCausalLM.from_pretrained(spec["model_id"], **load_kwargs)
     if device_map is None:
         model = model.to("cuda")
@@ -328,10 +356,18 @@ def use_model(key: str | None = None) -> str:
     return _active_key
 
 
-# Load the default brain eagerly at import — same as the other models, so the
-# ZeroGPU startup packing covers it and the common (no-switch) path pays no
-# load cost on the first turn.
-use_model(DEFAULT_AGENT_MODEL)
+# Load the default brain eagerly at import so ZeroGPU's startup tensor-packing
+# covers it and the common (no-switch) first turn pays no load cost. EXCEPTION: a
+# bitsandbytes-quantized default must NOT be built in the main process. Plain
+# .to("cuda") models are safe at import because the `spaces` library patches torch
+# and "packs" them into the forked GPU worker — but bitsandbytes initializes CUDA
+# directly (bypassing that patch), which hard-errors on ZeroGPU ("CUDA must not be
+# initialized in the main process") and crashes the Space at boot. So for a
+# quantized default, DEFER the load to first GPU use: the pipeline calls use_model()
+# inside its @spaces.GPU window (pipelines/agent_ask.py), and _generate() lazy-loads
+# as a backstop — both on the GPU, the only supported place to build a bnb model.
+if not _spec(DEFAULT_AGENT_MODEL).get("quantization"):
+    use_model(DEFAULT_AGENT_MODEL)
 
 
 def _template_kwargs() -> dict:
@@ -347,6 +383,12 @@ def _generate(
     """Greedy decode the assistant's next message. Traced as one `generation`
     (the resident brain as the model, the messages as input, the reply and the
     in/out token counts attached) when Langfuse is configured."""
+    # Backstop for a deferred (quantized) default brain: it isn't loaded at import
+    # on ZeroGPU, so build it on first use. Always reached inside a @spaces.GPU
+    # window (the pipeline's find turn / the eval's GPU fn) — the supported place to
+    # instantiate a bitsandbytes model. A no-op once a brain is resident.
+    if _MODEL is None:
+        use_model(DEFAULT_AGENT_MODEL)
     with tracing.generation(
         trace_name, model=_active_model_id(), input=messages
     ) as gen:

requirements.txt

@@ -2,6 +2,7 @@ spaces
 gradio
 transformers>=4.57.2,<5
 accelerate
+bitsandbytes  # int8/4bit agent-brain quantization (default brain is int8 MiniCPM4.1-8B)
 torchvision
 pymupdf
 pillow