IDU 0.2.0: add decider-4b as a second backend

app.py

@@ -13,24 +13,29 @@ WHAT IT DOES
     score  -> position on an ordered rubric (can land BETWEEN levels), distribution
     noul   -> one number: the probability the statement is true
 
-BACKEND: convaiinnovations/laya (Apache 2.0)
-  A 421M ModernBERT-large encoder with a decision head, trained by RL against strictly
-  proper scoring rules. Chosen over the alternatives for three concrete reasons:
-    * It IS the Jev shape -- `state` + typed questions in, typed decisions out. No
-      adapter layer, no tool-calling workaround, no triggers.
-    * Every option is scored at its own [MASK] token, then softmaxed over that
-      question's options. Options are judged independently, which is what Jev
-      documents ("each level is judged on its own against the state") and what makes
-      the polarity problem in a tool-calling model disappear: a noul question is just
-      two markers, not a competition between two armed tools.
-    * All questions in one call are answered in ONE forward pass, and it is PyTorch,
-      so it fits the ZeroGPU runtime natively.
-
-  Honest status of the base checkpoints, from the model's own card: they are near
-  chance zero-shot on the typed-decisions benchmark (0.362 against a 0.318 random and
-  0.461 majority-class baseline). The published 0.766 belongs to a checkpoint tuned on
-  that benchmark's own training split. Laya is a fast base to SPECIALISE. Treat the
-  numbers this Space reports as a baseline, not a capability ceiling.
+BACKENDS (two, same request shape)
+  laya    convaiinnovations/laya (Apache 2.0). 421M ModernBERT-large encoder with a
+          decision head, trained by RL against strictly proper scoring rules. Chosen for
+          three concrete reasons:
+            * It IS the Jev shape -- `state` + typed questions in, typed decisions out.
+              No adapter layer, no tool-calling workaround, no triggers.
+            * Every option is scored at its own [MASK] token, then softmaxed over that
+              question's options, so options are judged independently. That is what Jev
+              documents ("each level is judged on its own against the state") and it makes
+              the polarity problem in a tool-calling model disappear: a noul question is
+              just two markers, not two competing armed tools.
+            * All questions in one call are answered in ONE forward pass, and it is
+              PyTorch, so it fits the ZeroGPU runtime natively.
+  decider Mapika/decider-4b (Apache 2.0). 4B dense on Qwen3.5-4B-Base, one pass, no
+          decoding. Added because it takes the SAME TypeSafe request shape -- the authors
+          ship `systemone.py` implementing /v1/systemone -- so the whole adapter is the
+          backend branch below, and because it has no small option-count cap (255 options,
+          32k state tokens) where other open decision models stop at 16 options. It also
+          needs transformers>=5.17.0, which is why this Space requires that floor.
+
+  Both backends are selectable per call. They are NOT comparable for latency: both run on
+  the same ZeroGPU pool, so wall time measures queueing as much as compute. Accuracy is the
+  comparison; timing is not.
 
 IMPORT ORDER IS LOAD-BEARING, NOT STYLE
   `spaces` MUST be imported before torch. The spaces library patches torch's CUDA
@@ -72,7 +77,8 @@ print(f"import order: spaces before torch = {'torch' not in sys.modules}", flush
 import gradio as gr                          # noqa: E402  (pulls torch)
 
 MODEL_ID = "convaiinnovations/laya"
-SPACE_REVISION = "0.1.0"
+DECIDER_ID = "Mapika/decider-4b"
+SPACE_REVISION = "0.2.0"
 
 _AGENT: dict[str, Any] = {}
 
@@ -182,6 +188,154 @@ def warmup() -> dict:
             "warm_choice": out["answers"]["department"]["choice"]}
 
 
+# ------------------------------------------------------------------ decider backend
+# Mapika/decider-4b. The authors' own inference package is vendored verbatim in
+# `decider/` from the model repository (Apache 2.0), so the scoring path -- prompt layout,
+# per-question row isolation, isolated Score levels, restricting the answer logits to the
+# option-label tokens, the -inf masking of unused slots -- is theirs, not a reimplementation.
+#
+# Two deviations, both copied from the official decider demo Space:
+#   * the checkpoint is built at module scope, on CPU, and moved onto the GPU from inside a
+#     decorated call. Same reason as Laya: no CUDA device exists at import time, so building
+#     on "cuda" at startup binds the model to CPU and then raises from torch._C._cuda_init()
+#     inside the call.
+#   * temperature is passed per answer type instead of being instance state, so concurrent
+#     requests in one worker cannot race each other.
+
+DECIDER_CFG: dict[str, Any] = {}
+DECIDER_MODEL = None
+DECIDER_TOK = None
+DECIDER_T: dict[str, float] = {}
+
+
+def get_decider():
+    """Build the decider model once, at module scope, ON CPU."""
+    global DECIDER_MODEL, DECIDER_TOK, DECIDER_CFG, DECIDER_T
+    if DECIDER_MODEL is not None:
+        return DECIDER_MODEL
+    import torch
+    from huggingface_hub import hf_hub_download
+    from decider.model import DecisionModel
+
+    try:
+        DECIDER_CFG = json.load(open(hf_hub_download(DECIDER_ID, "decider_config.json")))
+    except Exception as e:                                    # pragma: no cover
+        print(f"decider: no decider_config.json ({type(e).__name__}); defaults in force",
+              flush=True)
+        DECIDER_CFG = {}
+    base = float(DECIDER_CFG.get("temperature", 1.0))
+    DECIDER_T = {k: float(v) for k, v in (DECIDER_CFG.get("temperature_by_type") or {}).items()}
+    for k in ("choice", "noul", "score"):
+        DECIDER_T.setdefault(k, base)
+    DECIDER_MODEL = DecisionModel(DECIDER_ID, dtype=torch.bfloat16, grad_ckpt=False).cpu().eval()
+    DECIDER_TOK = DECIDER_MODEL.tok
+    return DECIDER_MODEL
+
+
+class _KeepOrder:
+    """decider's rng stand-in: keep the caller's option order, never shuffle."""
+
+    def shuffle(self, x):
+        pass
+
+    def sample(self, xs, k):
+        return xs[:k]
+
+
+def _decider_temps(t_choice=None, t_score=None, t_noul=None) -> dict:
+    """Per-answer-type temperatures. 0 / None means 'keep the checkpoint's fitted value',
+    the same sentinel Laya uses, so the two backends take the same three numbers.
+
+    The per-type map matters: decider_config.json ships {choice: 1.11, noul: 1.56,
+    score: 1.287}, and serving every answer at the single 1.099 flattens the yes/no and
+    Score probabilities."""
+    t = dict(DECIDER_T)
+    for key, v in (("choice", t_choice), ("score", t_score), ("noul", t_noul)):
+        if v is None:
+            continue
+        v = float(v)
+        if v > 0:
+            t[key] = v
+    return t
+
+
+def _decider_move_to_gpu() -> str:
+    """Move the decider model onto CUDA from inside a decorated call. Same contract as the
+    Laya path: degrade to CPU rather than raise, so an unusable GPU is slow, not fatal."""
+    global DECIDER_MODEL
+    if DECIDER_MODEL is None:
+        return "unloaded"
+    import torch
+    if not ZERO:
+        return str(next(DECIDER_MODEL.parameters()).device)
+    try:
+        if not torch.cuda.is_available():
+            print("decider/ZeroGPU: no CUDA inside the call; staying on CPU", flush=True)
+            return str(next(DECIDER_MODEL.parameters()).device)
+        if next(DECIDER_MODEL.parameters()).device.type != "cuda":
+            DECIDER_MODEL = DECIDER_MODEL.to("cuda")
+            print("decider/ZeroGPU: model on cuda", flush=True)
+    except Exception as e:                                    # pragma: no cover
+        print(f"decider/ZeroGPU: move failed ({type(e).__name__}: {e}); CPU", flush=True)
+    return str(next(DECIDER_MODEL.parameters()).device)
+
+
+def _decider_systemone(state: Any, questions: dict, temps: dict) -> dict:
+    """decider.infer.Decider.system_one's eager path, with an explicit per-type temperature.
+
+    Every question gets its own row, so adding or removing a question cannot change another
+    answer. The packed single-row path is not used because the temperature is applied per
+    slot and the rows carry different answer types.
+    """
+    import torch
+    from decider.infer import Example, Q, neutralize_options
+    from decider.model import collate
+    from decider.prompt import MAX_OPTIONS, build
+    from decider.systemone import (assemble, plan_rows, render_question,
+                                   render_state, row_types)
+
+    ctx = render_state(state)
+    rqs = {k: render_question(v) for k, v in questions.items()}
+    neutralize = bool(DECIDER_CFG.get("neutralize_none", True))
+    opts = ((lambda r: neutralize_options(r["options"])[0]) if neutralize
+            else (lambda r: list(r["options"])))
+    isolated = bool(DECIDER_CFG.get("isolated_levels", False))
+    max_state = int(DECIDER_CFG.get("max_state_tokens", 32768))
+    flat, index = plan_rows(rqs, isolated)
+    items = [
+        build(Example(ctx, [Q(r["question"], opts(r), 0)]), DECIDER_TOK, _KeepOrder(),
+              max_options=MAX_OPTIONS, max_ctx_tokens=max_state, layout="state_first")
+        for r in flat
+    ]
+    rtypes = row_types(rqs, index)
+    base_t = float(DECIDER_CFG.get("temperature", 1.0))
+
+    probs = []
+    with torch.no_grad():
+        per = max(1, 65536 // max(len(it["ids"]) for it in items))
+        for i in range(0, len(items), per):
+            chunk = items[i:i + per]
+            bt = collate(chunk, DECIDER_TOK.pad_token_id)
+            lg = DECIDER_MODEL.slot_logits(
+                *[bt[k].to("cuda" if ZERO and torch.cuda.is_available() else "cpu")
+                  for k in ("input_ids", "attention_mask", "slot_idx", "slot_batch",
+                            "nopts")])
+            tvec = torch.tensor([temps.get(rtypes[i + j], base_t)
+                                 for j in range(len(chunk))],
+                                device=lg.device, dtype=lg.dtype)
+            pr = torch.softmax(lg / tvec.unsqueeze(-1), -1).float().cpu()
+            c = 0
+            for it in chunk:
+                probs.append(pr[c:c + len(it["slots"])])
+                c += len(it["slots"])
+    flatp = [p.tolist() for ps in probs for p in ps]
+    answers = assemble(rqs, index, flatp)
+    return {"model": f"decider-4b-{DECIDER_CFG.get('version', 'dev')}",
+            "answers": answers,
+            "usage": {"input_tokens": sum(len(it["ids"]) for it in items),
+                      "output_tokens": 0, "rows": len(items)}}
+
+
 def _normalise_questions(questions: dict) -> dict:
     """Accept Jev's shape directly; tolerate a couple of harmless variants.
 
@@ -232,12 +386,41 @@ def _apply_temperature(a, t_choice=None, t_score=None, t_noul=None) -> list:
 
 
 @GPU
-def answer_systemone(state: Any, questions: dict, temperature: list | None = None) -> dict:
-    """The single decorated entry point.
+def answer_systemone(state: Any, questions: dict, temperature: list | None = None,
+                     backend: str = "laya") -> dict:
+    """The single decorated entry point for every backend.
 
     Everything shares one GPU-decorated function: the start-up warm-up then covers all
     callers instead of each one paying its own first-call GPU attach.
+
+    `temperature` is [choice, score, noul] with 0 meaning "keep the checkpoint's fitted
+    value". Both backends take the same three numbers, but they are NOT the same
+    temperatures: laya's fitted values live in rl_agent_config.json and decider's in
+    decider_config.json, and each is left alone unless the caller overrides it.
     """
+    t0 = time.perf_counter()
+    temps = list(temperature or (0, 0, 0))
+    while len(temps) < 3:
+        temps.append(0)
+
+    if backend == "decider":
+        get_decider()
+        device_in_use = _decider_move_to_gpu()
+        dt = _decider_temps(temps[0], temps[1], temps[2])
+        res = _decider_systemone(state, questions, dt)
+        res["_idu"] = {
+            "space": f"dkappe/IDU {SPACE_REVISION}",
+            "backend": DECIDER_ID,
+            "device": device_in_use,
+            "zero_gpu": ZERO,
+            "latency_ms": round((time.perf_counter() - t0) * 1000, 1),
+            "temperature": [dt["choice"], dt["score"], dt["noul"]],
+            "note": ("decider-4b reads the option-label logits at one answer slot per "
+                     "question and never generates. Per-type temperatures are the "
+                     "checkpoint's fitted values unless overridden."),
+        }
+        return res
+
     a = get_agent()
     # Move onto the GPU HERE, inside the decorated call, where ZeroGPU has actually
     # attached one. Doing this at module scope cannot work: no device exists then.
@@ -245,7 +428,6 @@ def answer_systemone(state: Any, questions: dict, temperature: list | None = Non
     if temperature:
         _apply_temperature(a, *temperature)
     qs = _normalise_questions(questions)
-    t0 = time.perf_counter()
     res = a.predict(state, qs)
     res["_idu"] = {
         "space": f"dkappe/IDU {SPACE_REVISION}",
@@ -261,10 +443,10 @@ def answer_systemone(state: Any, questions: dict, temperature: list | None = Non
     return res
 
 
-def _safe_answer(state, questions, temperature=None):
+def _safe_answer(state, questions, temperature=None, backend="laya"):
     """Wrap the GPU call so failures show in the UI instead of killing the app."""
     try:
-        return answer_systemone(state, questions, temperature)
+        return answer_systemone(state, questions, temperature, backend)
     except Exception as e:                                   # pragma: no cover
         traceback.print_exc()
         return {"error": f"{type(e).__name__}: {e}",
@@ -404,11 +586,17 @@ def build_ui():
                 t2 = gr.Number(value=0, label="temp: score (0 = fitted)")
                 t3 = gr.Number(value=0, label="temp: noul (0 = fitted)")
             p_go = gr.Button("Ask", variant="primary")
+            p_backend = gr.Radio(choices=["laya", "decider"], value="laya",
+                                 label="backend",
+                                 info="laya = 421M ModernBERT + decision head. "
+                                      "decider = 4B Qwen3.5, 255 options / 32k state. "
+                                      "Do not read latency as a comparison: both share "
+                                      "one ZeroGPU pool.")
             p_rows = gr.Dataframe(headers=["question", "answer", "confidence"],
                                   col_count=(3, "fixed"), label="answers", wrap=True)
             p_raw = gr.Code(label="raw response", language="json")
 
-            def run_playground(state_text, q_text, tc, ts, tn):
+            def run_playground(state_text, q_text, tc, ts, tn, backend):
                 # Both boxes are gr.Code, but Gradio may hand us either a JSON string or an
                 # already-parsed object depending on version and input source. Handle both;
                 # the previous version only tried json.loads and blew up on a dict.
@@ -430,10 +618,10 @@ def build_ui():
                     qs = q_text
                 if not isinstance(qs, dict) or not qs:
                     return [], "questions must be a non-empty JSON object"
-                r = _safe_answer(state, qs, [tc, ts, tn])
+                r = _safe_answer(state, qs, [tc, ts, tn], backend or "laya")
                 return as_rows(r) if "answers" in r else [], json.dumps(r, indent=2)
 
-            p_go.click(run_playground, [p_state, p_q, t1, t2, t3],
+            p_go.click(run_playground, [p_state, p_q, t1, t2, t3, p_backend],
                        [p_rows, p_raw], api_name="systemone")
 
         with gr.Tab("Compare vs Needle 3"):
@@ -522,7 +710,7 @@ def compare_with_needle():
 
 
 def health():
-    """Report the truth about where the model actually ran.
+    """Report the truth about where each model actually ran.
 
     DELIBERATELY DOES NOT ASSERT ok=... ON THE WEB-PROCESS CACHE.
       An earlier version returned ok=(_AGENT["a"] is not None). On ZeroGPU that is a lie:
@@ -534,38 +722,80 @@ def health():
       bookkeeping, and `model_in_web_process` is reported separately for diagnosis.
     """
     warm = _AGENT.get("warmup") or {}
+    dwarm = _AGENT.get("warmup_decider") or {}
     a = _AGENT.get("a")
+    import transformers as _tf
     return {"ok": bool(warm.get("warm_choice")),
             "space": f"dkappe/IDU {SPACE_REVISION}",
-            "backend": MODEL_ID,
+            "backends": {"laya": MODEL_ID, "decider": DECIDER_ID},
             "last_warmup": warm,
             "warmup_device": warm.get("device"),
+            "decider_warmup": dwarm,
+            "transformers": _tf.__version__,
+            "decider_config_version": DECIDER_CFG.get("version"),
             "zero_gpu": ZERO,
             "device_mode_env": DEVICE_MODE,
             # diagnostic only -- False on ZeroGPU is expected, not a fault
             "model_in_web_process": a is not None,
+            "decider_in_web_process": DECIDER_MODEL is not None,
             "temperature_in_worker": _current_temperature(a) if a else None,
             "import_order_ok": "torch" in sys.modules,
             "note": ("ok reflects the last warm-up, because on ZeroGPU the model lives in "
                      "the GPU worker and model_in_web_process will read False by design.")}
 
 
+def warmup_decider() -> dict:
+    """Build decider-4b and run one real decision, so both backends are warm at startup.
+
+    This is the part that costs real memory: laya is 421M and decider is 4.2B, and both sit
+    in the same Space. Kept separate from `warmup` so a decider failure cannot take Laya
+    down with it -- the two are independent services sharing a UI.
+    """
+    try:
+        get_decider()
+        t0 = time.perf_counter()
+        dt = _decider_temps()
+        out = _decider_systemone(
+            "I was charged twice for order A-104. Please refund the duplicate.",
+            {"department": {"type": "choice",
+                            "instructions": "Which team should handle this?",
+                            "criteria": {"billing": "payments and refunds",
+                                         "technical": "bugs and outages",
+                                         "account": "login and access"}}},
+            dt)
+        return {"ms": round((time.perf_counter() - t0) * 1000, 1),
+                "device": str(next(DECIDER_MODEL.parameters()).device),
+                "warm_choice": out["answers"]["department"]["choice"],
+                "temperature": [dt["choice"], dt["score"], dt["noul"]]}
+    except Exception as e:                                    # pragma: no cover
+        traceback.print_exc()
+        return {"error": f"{type(e).__name__}: {e}"}
+
+
 demo = build_ui()   # safe here: every handler it references is defined above
 
 
-if __name__ == "__main__":
-    # Build and warm the model BEFORE the UI is reachable. Gradio runs this file as
-    # __main__, so a warm-up placed in an `else:` branch would never execute. Laya's own
-    # demo does the same thing for the same reason.
+def _startup():
+    """Warm both backends BEFORE the UI is reachable.
+
+    Gradio runs this file as __main__, so a warm-up placed in an `else:` branch would never
+    execute. Laya's own demo does the same thing for the same reason. Each backend is
+    warmed independently: a failure in one is reported and does not stop the other.
+    """
     try:
         _AGENT["warmup"] = warmup()
-        print(f"[startup] warm: {_AGENT['warmup']}", flush=True)
+        print(f"[startup] warm laya: {_AGENT['warmup']}", flush=True)
     except Exception as _e:                                   # pragma: no cover
         print(f"[startup] warmup failed: {type(_e).__name__}: {_e}", flush=True)
-    demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860)
-else:
     try:
-        _AGENT["warmup"] = warmup()
-        print(f"[startup] warm: {_AGENT['warmup']}", flush=True)
+        _AGENT["warmup_decider"] = warmup_decider()
+        print(f"[startup] warm decider: {_AGENT['warmup_decider']}", flush=True)
     except Exception as _e:                                   # pragma: no cover
-        print(f"[startup] warmup failed: {type(_e).__name__}: {_e}", flush=True)
+        print(f"[startup] warmup_decider failed: {type(_e).__name__}: {_e}", flush=True)
+
+
+if __name__ == "__main__":
+    _startup()
+    demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860)
+else:
+    _startup()

decider/infer.py

@@ -0,0 +1,357 @@
+"""Usable inference API: typed decisions with probabilities, all from one forward pass.
+
+    from decider.infer import Decider
+    d = Decider("runs/r2_full/model")
+    out = d.decide("My card was charged twice for the same purchase.",
+                   [{"question": "Which department should handle this?", "options": ["billing", "technical", "sales"]},
+                    {"question": "How urgent is this?", "options": ["low", "medium", "high"]}])
+    # -> [{'choice': 'billing', 'confidence': 0.97, 'probs': {...}}, {...}]
+"""
+import logging
+
+import torch
+from decider.model import DecisionModel, collate
+from decider.prompt import build, MAX_OPTIONS, resolve_layout, chat_template
+from decider import temperature as TT
+from dataclasses import dataclass
+
+
+@dataclass
+class Q:
+    text: str; options: list; gold: int = 0
+
+
+@dataclass
+class Example:
+    context: str; qs: list; task: str = "infer"; image: bytes = None
+
+
+logger = logging.getLogger(__name__)
+NEUTRAL_NONE = "not listed here"
+
+
+def neutralize_options(options):
+    """The training augmentation used the literal 'none of the above', and the model learned that exact string as an
+    abstain signal (it abstains even on clear cases when the string is offered). Any option that reads like it is
+    rewritten to a neutral phrasing for the model and mapped back in the output."""
+    out, back = [], {}
+    for o in options:
+        key = o.strip().lower()
+        if key.startswith("none of the above") or key in ("none of the above", "none", "n/a", "none of these"):
+            out.append(NEUTRAL_NONE); back[NEUTRAL_NONE] = o
+        else:
+            out.append(o)
+    return out, back
+
+
+class _NoShuffle:                              # keep option order as given
+    def shuffle(self, x): pass
+    def sample(self, xs, k): return xs[:k]
+
+
+class CompiledSchema:
+    def __init__(self, d, rqs, h, index):
+        from decider.systemone import row_types
+        self.d, self.rqs, self.h, self.index = d, rqs, h, index
+        self.types = row_types(rqs, index)                         # answer type of every schema row (decider.temperature)
+
+    def batch(self, states, max_state_tokens=32768):
+        from decider.systemone import render_state, assemble
+        T = TT.for_types(self.d.T_schema, self.d.T_schema_by_type, self.types)
+        probs = self.d._se.score(self.h, [render_state(s) for s in states], temperature=T, max_ctx_tokens=max_state_tokens)
+        return [{"model": self.d.name, "answers": assemble(self.rqs, self.index, [p.tolist() for p in pr])} for pr in probs]
+
+    def __call__(self, state, max_state_tokens=32768):
+        return self.batch([state], max_state_tokens)[0]
+
+
+class Decider:
+    """One-pass decisions with automatic CUDA, MPS, or CPU device selection.
+
+    CUDA uses shape-bucketed graphs by default. MPS defaults to float16 and uses
+    the optional MPS patch; CPU defaults to bfloat16. Set ``use_graphs=False``
+    for eager execution or debugging.
+    """
+    def __init__(self, path, device=None, dtype=None, temperature=None, abstain_below=0.0, use_graphs=None, temperature_by_type=None):
+        """The prompt layout comes from decider_config.json: "layout": "chat" (chat-trained checkpoints) wraps every prompt in the
+        tokenizer's chat template (decider.prompt.build_chat); no "layout" key is the plain layout of every earlier model.
+        An unknown layout raises ValueError before the weights are loaded.
+
+        Temperatures (decider.temperature): decider_config.json "temperature" and the optional "temperature_by_type"
+        {"choice": T, "noul": T, "score": T}.  temperature= overrides "temperature" and switches the config's by-type map off;
+        temperature_by_type= sets the map explicitly.  An invalid temperature or map key raises ValueError before the weights
+        are loaded."""
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else ("mps" if torch.backends.mps.is_available() else "cpu")
+        if dtype is None:
+            dtype = torch.float16 if str(device).startswith("mps") else torch.bfloat16
+        logger.info("Decider device=%s dtype=%s", device, dtype)
+        import json, os
+        cfg = {}
+        try:                                          # model folder may carry decider_config.json (temperature, flags)
+            from huggingface_hub import hf_hub_download
+            cfg_path = os.path.join(path, "decider_config.json") if os.path.isdir(path) else hf_hub_download(path, "decider_config.json")
+            cfg = json.load(open(cfg_path))
+        except Exception:
+            pass
+        self.layout = resolve_layout(cfg)
+        (temperature, self.T_by_type), (T_schema, self.T_schema_by_type) = TT.from_config(cfg, temperature, temperature_by_type)
+        self.neutralize_none = bool(cfg.get("neutralize_none", True))   # v4 and earlier learned the literal string as an abstain signal
+        if use_graphs is None:
+            use_graphs = str(device).startswith("cuda")
+        if use_graphs:
+            from decider.engine import Engine
+            self.eng = Engine(path, device=device, dtype=dtype); self.m = self.eng.m
+        else:
+            if str(device).startswith("mps"):
+                from decider.mps_ops import patch_mps
+                patch_mps()
+            self.eng = None; self.m = DecisionModel(path, dtype=dtype, grad_ckpt=False).to(device).eval()
+        self.chat = chat_template(self.m.tok) if self.layout == "chat" else None      # None: plain layout, prompts as in 1.1.x
+        self.dev = device; self.T = temperature; self.abstain_below = abstain_below
+        self.name = "decider-" + str(cfg.get("version", "dev"))
+        self.schema_first = bool(cfg.get("schema_first", False)) and self.eng is not None      # default layout. Questions-first (the cacheable one) costs accuracy
+        self.T_schema = T_schema                                              # (about 1.5 points on fixed label sets, more elsewhere): opt in with schema()
+        self.isolated_levels = bool(cfg.get("isolated_levels", False))      # Score levels judged one per row (v8+)
+        self._se = None; self._schemas = {}
+
+    def _decide_items(self, requests, max_ctx_tokens=1536):
+        """The prompt rows of decide_batch: -> (requests with neutralized options, one item per request)."""
+        exs = []
+        if self.neutralize_none:
+            requests = [(context, [dict(q, options=neutralize_options(q["options"])[0], _back=neutralize_options(q["options"])[1]) for q in qs]) for context, qs in requests]
+        for context, qs in requests:
+            for q in qs:
+                assert 2 <= len(q["options"]) <= MAX_OPTIONS, f"2..{MAX_OPTIONS} options required"
+            exs.append(Example(context, [Q(q["question"], list(q["options"]), 0) for q in qs], "infer"))
+        items = [build(e, self.m.tok, _NoShuffle(), max_options=MAX_OPTIONS, max_ctx_tokens=max_ctx_tokens, chat=self.chat) for e in exs]
+        for it, (_, qs) in zip(items, requests):                     # answer type per slot: a plain question is "choice"
+            it["types"] = [q.get("_type", "choice") for q in qs]
+        return requests, items
+
+    @torch.no_grad()
+    def decide_batch(self, requests, max_ctx_tokens=1536):
+        """requests: list of (context:str, questions:list[dict(question, options)]). One forward pass for everything."""
+        requests, items = self._decide_items(requests, max_ctx_tokens)
+        T = TT.for_items(self.T, self.T_by_type, items)                  # the scalar self.T when there is no by-type map
+        if self.eng is not None:
+            probs = torch.cat(self.eng.score_items(items, temperature=T))
+        else:
+            b = collate(items, self.m.tok.pad_token_id)
+            logits = self.m.slot_logits(b["input_ids"].to(self.dev), b["attention_mask"].to(self.dev), b["slot_idx"].to(self.dev),
+                                        b["slot_batch"].to(self.dev), b["nopts"].to(self.dev))
+            probs = TT.scaled_softmax(logits, TT.slot_temperatures(T, items)).cpu()
+        out, k = [], 0
+        for context, qs in requests:
+            res = []
+            for q in qs:
+                p = probs[k, :len(q["options"])].tolist(); k += 1
+                j = max(range(len(p)), key=p.__getitem__); back = q.get("_back", {})
+                names = [back.get(o, o) for o in q["options"]]
+                res.append(dict(choice=names[j] if p[j] >= self.abstain_below else None, confidence=p[j],
+                                probs={o: pi for o, pi in zip(names, p)}, probs_list=p))
+            out.append(res)
+        return out
+
+    def decide(self, context, questions, **kw):
+        return self.decide_batch([(context, questions)], **kw)[0]
+
+    # ---- Jev-shaped interface (decider.systemone): state + {id: Choice | Score | Noul with criteria}
+    # ---- schema cache (v7+): the questions are run once, requests only run the state (decider.schema_engine)
+    def schema(self, questions, independent=True, isolated=None, compile=False):
+        """Compile a fixed set of Jev-shaped questions: schema(state) -> answers; schema.batch([state, ...]) -> [answers]."""
+        import json
+        from decider.schema_engine import SchemaEngine
+        from decider.systemone import render_question
+        isolated = self.isolated_levels if isolated is None else isolated
+        key = (json.dumps(questions, sort_keys=True, ensure_ascii=False), independent, isolated)
+        if key not in self._schemas:
+            if self._se is None: self._se = SchemaEngine(self.eng, chat=self.chat)
+            if len(self._schemas) >= 64:                                  # drop the oldest schema and its graphs
+                old = next(iter(self._schemas)); hid = self._schemas.pop(old)[1].id
+                for k in [k for k in self._se.graphs if k[0] == hid]: del self._se.graphs[k]
+            from decider.systemone import plan_rows
+            rqs = {k: render_question(v) for k, v in questions.items()}
+            rows, index = plan_rows(rqs, isolated and independent)
+            h = self._se.prepare(rows, independent=independent, compile=compile)      # compile=True: ~25 s per (batch, length) shape, 1.6x faster after
+            self._schemas[key] = (rqs, h, index)
+        return CompiledSchema(self, *self._schemas[key])
+
+    def system_one(self, state, questions, independent=True, max_state_tokens=32768, max_fwd_tokens=65536, layout=None, isolated=None):
+        layout = layout or ("schema_first" if self.schema_first else "state_first")
+        isolated = (self.isolated_levels if isolated is None else isolated) and independent
+        if layout == "schema_first" and self.eng is not None:
+            return self.schema(questions, independent, isolated)(state, max_state_tokens)
+        """independent=True scores every question in its own row (state + that question only), so adding, removing or
+        reordering questions cannot change any other answer; the state is run once and its cache forked to every
+        question (Engine.score_shared).  independent=False packs all questions behind one copy of the state in one row
+        (later questions can then see earlier question texts)."""
+        from decider.systemone import unique_tokens, assemble
+        rqs, index, items = self._system_one_items(state, questions, independent, max_state_tokens, layout, isolated)
+        flatp = self._system_one_probs(items, layout, max_fwd_tokens, TT.for_items(self.T, self.T_by_type, items))
+        return {"model": self.name, "answers": assemble(rqs, index, flatp),
+                "usage": {"input_tokens": unique_tokens(items), "output_tokens": 0}}
+
+    @torch.no_grad()
+    def _system_one_probs(self, items, layout, max_fwd_tokens=65536, temperature=None):
+        """Score system_one's uncached rows.  temperature: as Engine.score_items takes it (a number, or one entry per item).
+        -> one probability list per question row, in row order."""
+        if self.eng is not None and len(items) > 1 and layout == "state_first":
+            probs = self.eng.score_shared(items, temperature=temperature)
+        else:
+            probs = []; per = max(1, max_fwd_tokens // max(len(it["ids"]) for it in items))
+            for i in range(0, len(items), per):
+                T = TT.item_slice(temperature, i, i + per)
+                if self.eng is not None:
+                    probs += self.eng.score_items(items[i:i + per], temperature=T)
+                else:
+                    bt = collate(items[i:i + per], self.m.tok.pad_token_id)
+                    lg = self.m.slot_logits(*[bt[k].to(self.dev) for k in ("input_ids", "attention_mask", "slot_idx", "slot_batch", "nopts")])
+                    pr = TT.scaled_softmax(lg, TT.slot_temperatures(T, items[i:i + per])).cpu(); c = 0
+                    for it in items[i:i + per]:
+                        probs.append(pr[c:c + len(it["slots"])]); c += len(it["slots"])
+        return [p.tolist() for ps in probs for p in ps]
+
+    def _system_one_items(self, state, questions, independent=True, max_state_tokens=32768, layout=None, isolated=None):
+        """The prompt rows of system_one's uncached path: -> (rendered questions, answer index, items)."""
+        from decider.systemone import render_state, render_question, plan_rows, row_types
+        layout = layout or ("schema_first" if self.schema_first else "state_first")
+        isolated = (self.isolated_levels if isolated is None else isolated) and independent
+        ctx = render_state(state); rqs = {k: render_question(v) for k, v in questions.items()}
+        opts = (lambda r: neutralize_options(r["options"])[0]) if self.neutralize_none else (lambda r: list(r["options"]))
+        flat, index = plan_rows(rqs, isolated)
+        rows = [[r] for r in flat] if independent else [flat]
+        items = [build(Example(ctx, [Q(r["question"], opts(r), 0) for r in row]), self.m.tok, _NoShuffle(), max_options=MAX_OPTIONS,
+                       max_ctx_tokens=max_state_tokens, layout=layout, chat=self.chat) for row in rows]
+        types = row_types(rqs, index)                                 # answer type per row (decider.temperature)
+        for it, ts in zip(items, [[t] for t in types] if independent else [types]):
+            it["types"] = ts
+        return rqs, index, items
+
+    # ---- typed schema interface: {question: {"type": "bool"} | {"type": "choice", "options": [...]}
+    #                                         | {"type": "scale", "legend": {"0": "none", "1": "low", ...}}}
+    SCHEMA_FORM = ('schema: a map {question: field}, each field one of {"type": "choice", "options": [option strings]}, '
+                   '{"type": "bool"} or {"type": "scale", "legend": [descriptions] or {level number: description}}')
+
+    @staticmethod
+    def _check_schema(schema):
+        """Raise ValueError naming the expected form when `schema` does not have it (the HTTP server turns this into a 422).
+        Every schema that 1.1.2 answered stays accepted, except options or a legend given as a bare string (1.1.2 split it into
+        characters); an empty schema is answered with {}."""
+        import json, math
+        form = Decider.SCHEMA_FORM
+        if schema is None:
+            raise ValueError("schema is required; " + form)
+        if not isinstance(schema, dict):
+            raise ValueError(f"schema is a {type(schema).__name__}; " + form)
+        for qtext, spec in schema.items():
+            where = f"schema[{qtext!r}]"
+            if not isinstance(spec, dict):
+                raise ValueError(f"{where} is a {type(spec).__name__}, not a field object; " + form)
+            t = spec.get("type", "choice")
+            if t == "choice":
+                opts = spec.get("options")
+                if not isinstance(opts, (list, tuple, dict)) or not opts or not all(isinstance(o, str) for o in opts):
+                    raise ValueError(f'{where}: "options" must be a non-empty list of strings; ' + form)
+            elif t == "scale":
+                leg = spec.get("legend")
+                if not isinstance(leg, (list, tuple, dict)) or not leg:
+                    raise ValueError(f'{where}: "legend" must be a non-empty list or {{level number: description}} map; ' + form)
+                try:                                           # the legend is echoed in the answer, which must serialise
+                    json.dumps(leg, allow_nan=False)
+                except (TypeError, ValueError):
+                    raise ValueError(f'{where}: the "legend" contains a value that is not finite JSON (NaN or Infinity); ' + form)
+                if isinstance(leg, dict):
+                    try:
+                        ok = all(math.isfinite(float(k)) for k in leg)
+                    except (TypeError, ValueError, OverflowError):
+                        ok = False
+                    if not ok:
+                        raise ValueError(f'{where}: the keys of a "legend" map must be finite numbers, e.g. {{"0": "none", "1": "low"}}; ' + form)
+            elif t != "bool":
+                raise ValueError(f"{where}: unknown field type {t!r}; " + form)
+
+    @staticmethod
+    def _schema_to_questions(schema):
+        Decider._check_schema(schema)
+        qs = []
+        for qtext, spec in schema.items():
+            t = spec.get("type", "choice")
+            if t == "bool":
+                qs.append(dict(question=qtext, options=["no", "yes"], _type="noul"))
+            elif t == "choice":
+                qs.append(dict(question=qtext, options=list(spec["options"]), _type="choice"))
+            elif t == "scale":
+                leg = spec["legend"]
+                keys = sorted(leg, key=lambda k: float(k)) if isinstance(leg, dict) else list(range(len(leg)))
+                labels = [f"{k}: {leg[k]}" if isinstance(leg, dict) else f"{i}: {leg[i]}" for i, k in enumerate(keys)]
+                qs.append(dict(question=qtext, options=labels, _keys=keys, _legend=leg, _type="score"))
+            else:
+                raise ValueError(f"unknown field type {t}")
+        return qs
+
+    def decide_json_batch(self, requests, **kw):
+        """requests: list of (context, schema). Returns one dict per context keyed by question."""
+        qss = [self._schema_to_questions(schema) for _, schema in requests]
+        raw = self.decide_batch([(ctx, qs) for (ctx, _), qs in zip(requests, qss)], **kw)
+        out = []
+        for (ctx, schema), qs, res in zip(requests, qss, raw):
+            o = {}
+            for (qtext, spec), q, r in zip(schema.items(), qs, res):
+                t = spec.get("type", "choice")
+                if t == "bool":
+                    o[qtext] = {"noul": round(r["probs"]["yes"], 4), "type": "noul"}
+                elif t == "choice":
+                    o[qtext] = {"choice": r["choice"], "confidence": round(r["confidence"], 4), "type": "choice",
+                                "probabilities": {k: round(v, 4) for k, v in r["probs"].items()}}
+                else:
+                    p = [r["probs"][lab] for lab in q["options"]]
+                    keys = q["_keys"]; n = len(p)
+                    score = sum(float(k) * pi for k, pi in zip(keys, p))          # expected level on the legend scale
+                    j = max(range(n), key=p.__getitem__)
+                    o[qtext] = {"score": round(score, 2), "confidence": round(p[j], 4), "type": "scale", "legend": q["_legend"],
+                                "probabilities": {str(keys[i]): round(pi, 4) for i, pi in enumerate(p)}}
+            out.append(o)
+        return out
+
+    def decide_json(self, context, schema, **kw):
+        return self.decide_json_batch([(context, schema)], **kw)[0]
+
+
+if __name__ == "__main__":
+    import sys, json, time
+    d = Decider(sys.argv[1] if len(sys.argv) > 1 else "runs/r1_200k/model")
+    demo = [
+        ("My card was charged twice for the same purchase and I want the extra charge refunded.",
+         [{"question": "Which department should handle this?", "options": ["billing", "technical support", "sales"]},
+          {"question": "What is the customer's sentiment?", "options": ["angry", "neutral", "happy"]},
+          {"question": "Does this need a refund action?", "options": ["no", "yes"]}]),
+        ("hey can u turn the lights off in the kitchen",
+         [{"question": "What is the intent?", "options": ["smart home control", "set alarm", "play music", "none of the above"]},
+          {"question": "Is this request toxic?", "options": ["no", "yes"]}]),
+        ("The quarterly report shows revenue fell 12% while costs rose sharply.",
+         [{"question": "What is the financial sentiment?", "options": ["bearish", "neutral", "bullish"]}]),
+    ]
+    t = time.time(); res = d.decide_batch(demo); dt = time.time() - t
+    for (ctx, qs), r in zip(demo, res):
+        print("\n>>", ctx)
+        for q, a in zip(qs, r):
+            print(f"   {q['question']:45s} -> {a['choice']!s:22s} p={a['confidence']:.2f}  " + " ".join(f"{o}:{p:.2f}" for o, p in a['probs'].items()))
+    print(f"\n{sum(len(q) for _, q in demo)} decisions in {dt*1000:.0f} ms (one forward pass)")
+    schema = {
+        "Revenue currently impacted?": {"type": "bool"},
+        "What business impact?": {"type": "choice", "options": ["none", "degraded", "outage"]},
+        "Integration issue present?": {"type": "bool"},
+        "Account health status?": {"type": "choice", "options": ["healthy", "watch", "at risk"]},
+        "Which incident scope?": {"type": "choice", "options": ["single_account", "multi_account", "platform_wide"]},
+        "Security concern present?": {"type": "bool"},
+        "Duplicate charge reported?": {"type": "bool"},
+        "Churn likelihood level?": {"type": "scale", "legend": {"0": "none", "1": "low", "2": "medium", "3": "high"}},
+        "Human attention needed?": {"type": "bool"},
+        "Immediate feature request?": {"type": "bool"},
+    }
+    ctx = ("Hi, since this morning our Stripe webhook integration stopped firing and our checkout is down for all customers. "
+           "We are losing orders every minute and our partner launch is on Thursday. Also I think we got billed twice last week. "
+           "If this is not fixed today we will have to look at other providers.")
+    t = time.time(); js = d.decide_json(ctx, schema); dt = time.time() - t
+    print(f"\n>> {ctx[:80]}...\n" + json.dumps(js, indent=1)[:3000]); print(f"{len(schema)} typed fields in {dt*1000:.0f} ms (one forward pass)")

decider/model.py

@@ -0,0 +1,49 @@
+"""Backbone -> slot hidden states -> restricted logits over option letters."""
+import torch, torch.nn as nn, torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from decider.prompt import letter_ids, MAX_OPTIONS
+
+
+class DecisionModel(nn.Module):
+    def __init__(self, name, dtype=torch.bfloat16, grad_ckpt=True):
+        super().__init__()
+        if hasattr(torch.backends.cuda, "enable_cudnn_sdp"):   # as decider.engine.set_attention_backend_policy: the cuDNN SDPA
+            torch.backends.cuda.enable_cudnn_sdp(False)         # backend is wrong for masked attention on Blackwell (torch 2.14)
+        self.tok = AutoTokenizer.from_pretrained(name)
+        self.lm = AutoModelForCausalLM.from_pretrained(name, dtype=dtype)
+        if grad_ckpt:
+            self.lm.gradient_checkpointing_enable()
+        self.register_buffer("letters", torch.tensor(letter_ids(self.tok)), persistent=False)
+
+    def slot_logits(self, input_ids, attention_mask, slot_idx, slot_batch, nopts):
+        """input_ids [B,T]; slot_idx/slot_batch [N] flat slot positions; nopts [N].
+        Returns [N, MAX_OPTIONS] logits with invalid options masked to -inf."""
+        h = self.lm.model(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
+        hs = h[slot_batch, slot_idx]                                   # [N,H]
+        W = self.lm.lm_head.weight[self.letters]                       # [K,H]
+        logits = F.linear(hs, W).float()                               # [N,K]
+        ar = torch.arange(MAX_OPTIONS, device=logits.device)[None, :]
+        logits = logits.masked_fill(ar >= nopts[:, None], float("-inf"))
+        return logits
+
+    def forward(self, batch):
+        return self.slot_logits(batch["input_ids"], batch["attention_mask"], batch["slot_idx"], batch["slot_batch"], batch["nopts"])
+
+
+def collate(items, pad_id):
+    """items: list of dicts from prompt.build (+ 'task', 'ex_id'). Right-pad."""
+    T = max(len(it["ids"]) for it in items)
+    T = ((T + 63) // 64) * 64          # few distinct shapes -> fewer kernel (re)compiles
+    B = len(items)
+    input_ids = torch.full((B, T), pad_id, dtype=torch.long)
+    attn = torch.zeros((B, T), dtype=torch.long)
+    slot_idx, slot_batch, golds, nopts, tasks, qidx = [], [], [], [], [], []
+    for b, it in enumerate(items):
+        n = len(it["ids"])
+        input_ids[b, :n] = torch.tensor(it["ids"])
+        attn[b, :n] = 1
+        for k, s in enumerate(it["slots"]):
+            slot_idx.append(s); slot_batch.append(b); golds.append(it["golds"][k]); nopts.append(it["nopts"][k])
+            tasks.append(it.get("task", "")); qidx.append(k)
+    return dict(input_ids=input_ids, attention_mask=attn, slot_idx=torch.tensor(slot_idx), slot_batch=torch.tensor(slot_batch),
+                golds=torch.tensor(golds), nopts=torch.tensor(nopts), tasks=tasks, qidx=qidx)

decider/prompt.py

@@ -0,0 +1,287 @@
+"""Prompt construction.  One context, N typed questions, N answer slots.
+
+All N decisions are read from a single forward pass: the logits at each
+"Answer k: (" slot are restricted to the option-letter tokens.  No answer
+letters are ever inserted, so slot k sees the context and all questions but
+no earlier answers (the decisions are conditionally independent given input).
+"""
+import random
+
+LETTERS = "ABCDEFGHIJ"
+NARROW = len(LETTERS)      # <= NARROW options: the original "(A) .. (J)" rendering, tokenized as a string (unchanged since v1)
+MAX_OPTIONS = 255          # width of the label head. > NARROW options: "wide" rendering, one label token per option:
+                           # A..Z then the first 229 two-letter upper-case strings that are single tokens (AA, AB, ...)
+ABSTAIN_PREFIXES = ("none of the above", "none of these", "not listed", "no suitable", "does not apply", "cannot tell")
+ABSTAIN_EXACT = ("other", "unsure", "something else", "neither of these", "other / not covered")
+
+
+def is_abstain_option(o):
+    o = o.strip().lower()
+    return o.startswith(ABSTAIN_PREFIXES) or o in ABSTAIN_EXACT
+
+
+_LABELS = {}
+_OPT_CACHE = {}
+
+
+def _enc_opt(tok, text):
+    """Token ids of ") <option text>" (cached: fixed label sets repeat the same strings millions of times)."""
+    key = (id(tok), text)
+    v = _OPT_CACHE.get(key)
+    if v is None:
+        v = tok.encode(f") {text}", add_special_tokens=False)
+        if len(_OPT_CACHE) < 2_000_000:
+            _OPT_CACHE[key] = v
+    return v
+
+
+def label_table(tok):
+    """(label strings, label token ids), MAX_OPTIONS entries; the first NARROW are A..J so narrow questions are unchanged."""
+    key = id(tok)
+    if key not in _LABELS:
+        import string
+        U = string.ascii_uppercase
+        names = list(U) + [a + b for a in U for b in U]
+        out = []
+        for n in names:
+            t = tok.encode(n, add_special_tokens=False)
+            if len(t) == 1:
+                out.append((n, t[0]))
+            if len(out) == MAX_OPTIONS:
+                break
+        assert len(out) == MAX_OPTIONS and len({i for _, i in out}) == MAX_OPTIONS
+        _LABELS[key] = ([n for n, _ in out], [i for _, i in out],
+                        tok.encode("\n(", add_special_tokens=False))
+    return _LABELS[key]
+
+
+def _select(q, rng, max_options):
+    opts = list(range(len(q.options)))
+    if len(opts) > max_options:
+        # always keep the gold and any abstain-style option (its mere presence must not carry information)
+        forced = {q.gold} | {i for i, o in enumerate(q.options) if is_abstain_option(o)}
+        others = [i for i in opts if i not in forced]
+        opts = rng.sample(others, max_options - len(forced)) + list(forced)
+    rng.shuffle(opts)
+    return opts
+
+
+def _options_ids(tok, q, opts):
+    if len(opts) <= NARROW:
+        return tok.encode("".join(f"\n({LETTERS[j]}) {q.options[oi]}" for j, oi in enumerate(opts)), add_special_tokens=False)
+    _, lab_ids, open_ids = label_table(tok); out = []
+    for j, oi in enumerate(opts):
+        out += open_ids + [lab_ids[j]] + _enc_opt(tok, q.options[oi])
+    return out
+
+
+def build_schema_first(example, tok, rng=None, max_options=NARROW, max_ctx_tokens=1536, chat=None):
+    """Schema-first layout: all question/option blocks, then the context, then one answer slot per question.
+
+        Question 1: ...\nOptions:\n(A) ...          <- prefix: depends only on the questions, so its cache (attention KV and
+        \n\nQuestion 2: ...                            delta-net states) is computed once per schema and reused for every state
+        \n\nContext:\n<state>\n\nAnswer 1: (\nAnswer 2: (
+
+    The three parts are tokenized separately, so `ids[:prefix_len]` is identical for every state.
+    chat: a ChatTemplate for a chat-layout model (see `build_chat`); None renders the plain layout above."""
+    rng = rng or random
+    perms = [_select(q, rng, max_options) for q in example.qs]
+    pre = schema_prefix_ids(tok, example.qs, perms, chat=chat)
+    suf, slots = schema_suffix_ids(tok, example.context, len(example.qs), max_ctx_tokens, chat=chat)
+    return dict(ids=pre + suf, slots=[len(pre) + s for s in slots], golds=[p.index(q.gold) if q.gold in p else -1 for p, q in zip(perms, example.qs)],
+                nopts=[len(p) for p in perms], perms=perms, prefix_len=len(pre))
+
+
+def schema_prefix_ids(tok, qs, perms=None, chat=None):
+    """Token ids of the question/option blocks (the cacheable part of the schema-first layout).
+    chat: a ChatTemplate; the prefix then starts with the template head (the user turn opens before the first question)."""
+    multi = len(qs) > 1; pre = [] if chat is None else list(chat.head)
+    for k, q in enumerate(qs):
+        opts = perms[k] if perms is not None else list(range(len(q.options)))
+        pre += tok.encode(f"{chr(10) * 2 if k else ''}Question{' ' + str(k + 1) if multi else ''}: {q.text}\nOptions:", add_special_tokens=False) + _options_ids(tok, q, opts)
+    return pre
+
+
+def schema_suffix_ids(tok, context, n_q, max_ctx_tokens=1536, chat=None):
+    """Token ids after the schema prefix: the context and one answer slot per question. Returns (ids, slot positions in ids).
+    chat: a ChatTemplate; the context then ends the user turn, and the template tail and the answer pieces follow."""
+    ids = tok.encode("\n\nContext:\n", add_special_tokens=False) + tok.encode(context, add_special_tokens=False)[:max_ctx_tokens]; slots = []
+    if chat is not None:
+        ids += chat.tail
+        for k in range(n_q):
+            ids += chat.answer_ids(tok, k, n_q > 1); slots.append(len(ids) - 1)
+        return ids, slots
+    for k in range(n_q):
+        ids += tok.encode(f"{chr(10) * 2 if k == 0 else chr(10)}Answer{' ' + str(k + 1) if n_q > 1 else ''}: (", add_special_tokens=False); slots.append(len(ids) - 1)
+    return ids, slots
+
+
+def build(example, tok, rng=None, max_options=NARROW, max_ctx_tokens=1536, layout="state_first", chat=None):
+    """Returns dict(ids=list[int], slots=list[int], golds=list[int], nopts=list[int], perms=list[list[int]]).
+    chat: a ChatTemplate (chat_template(tok)) for a model trained in the chat layout (decider_config.json "layout": "chat");
+    None, the default, is the plain layout every earlier model uses, unchanged."""
+    if layout == "schema_first":
+        return build_schema_first(example, tok, rng, max_options, max_ctx_tokens, chat=chat)
+    if chat is not None:
+        return build_chat(example, tok, chat, rng, max_options, max_ctx_tokens)
+    rng = rng or random
+    ctx_ids = tok.encode("Context:\n" + example.context, add_special_tokens=False)[:max_ctx_tokens]
+    ids = list(ctx_ids)
+    slots, golds, nopts, perms = [], [], [], []
+    multi = len(example.qs) > 1
+    for k, q in enumerate(example.qs):
+        opts = list(range(len(q.options)))
+        if len(opts) > max_options:
+            # always keep the gold and any abstain-style option (its mere presence must not carry information)
+            forced = {q.gold} | {i for i, o in enumerate(q.options) if is_abstain_option(o)}
+            others = [i for i in opts if i not in forced]
+            keep = rng.sample(others, max_options - len(forced)) + list(forced)
+            opts = keep
+        rng.shuffle(opts)
+        head = f"\n\nQuestion{' ' + str(k + 1) if multi else ''}: {q.text}\nOptions:"
+        tail = f"\nAnswer{' ' + str(k + 1) if multi else ''}: ("
+        if len(opts) <= NARROW:
+            lines = [head] + [f"\n({LETTERS[j]}) {q.options[oi]}" for j, oi in enumerate(opts)] + [tail]
+            piece = tok.encode("".join(lines), add_special_tokens=False)
+        else:                                   # wide: "\n(" + <label token> + ") text", built from ids so every label is one token
+            _, lab_ids, open_ids = label_table(tok)
+            piece = tok.encode(head, add_special_tokens=False)
+            for j, oi in enumerate(opts):
+                piece += open_ids + [lab_ids[j]] + _enc_opt(tok, q.options[oi])
+            piece += tok.encode(tail, add_special_tokens=False)
+        ids.extend(piece)
+        slots.append(len(ids) - 1)          # position of " (" token
+        golds.append(opts.index(q.gold) if q.gold in opts else -1)
+        nopts.append(len(opts))
+        perms.append(opts)
+    return dict(ids=ids, slots=slots, golds=golds, nopts=nopts, perms=perms)
+
+
+# ---- chat layout (1.2.0) ----------------------------------------------------------------------------------------------
+# A model whose decider_config.json has "layout": "chat" (or "chat_template": true) was trained with every prompt wrapped
+# in its tokenizer's chat template: one user turn holding the plain content, thinking switched off, and the answer pieces in
+# the assistant turn.  For Qwen3.5, state-first:
+#
+#     <|im_start|>user\n  Context:\n<state>  \n\nQuestion: <q>\nOptions:\n(A) ..\n(B) ..
+#     <|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n  Answer: (
+#
+# With several questions in one row all question blocks come first and the answer pieces ("Answer 1: (", "\nAnswer 2: (",
+# ...) follow the template tail.  Schema-first: the user turn holds the question blocks and then "\n\nContext:\n<state>".
+# Every part is tokenized on its own (head, context, each question header, each option block, tail, each answer piece);
+# the letter is read at the final " (" token as in the plain layout.
+LAYOUTS = ("plain", "chat")
+
+
+def resolve_layout(cfg):
+    """The prompt layout a decider_config.json names: "plain" (no "layout" key and no "chat_template": true, which is every
+    released model) or "chat".  Raises ValueError for any other value, so a model trained in a layout
+    this version does not know is refused instead of being read in the wrong one."""
+    cfg = cfg or {}
+    layout = cfg.get("layout")
+    if layout is None:
+        layout = "chat" if cfg.get("chat_template") is True else "plain"
+    if layout not in LAYOUTS:
+        raise ValueError(f"decider_config.json names the prompt layout {layout!r}; this version of decider-ai knows "
+                         f"{', '.join(repr(x) for x in LAYOUTS)}. Upgrade decider-ai, or check the model's config.")
+    if layout == "plain" and cfg.get("chat_template") is True:
+        raise ValueError('decider_config.json says "layout": "plain" and "chat_template": true; these contradict each other')
+    return layout
+
+
+class ChatTemplate:
+    """Token ids of the tokenizer's chat template around one user turn, and the answer pieces of the assistant turn.
+
+    head/tail come from tok.apply_chat_template([user turn], add_generation_prompt=True) with thinking disabled
+    (enable_thinking=False where the template knows the switch; a thinking block the template leaves open is closed here),
+    with no system prompt.  This is the computation of the chat-layout research server the chat models were trained against."""
+    SENTINEL = "@@DECIDER_USER_CONTENT@@"
+
+    def __init__(self, tok, answer="Answer"):
+        if not getattr(tok, "chat_template", None):
+            raise ValueError('the model is configured for the chat layout ("layout": "chat") but its tokenizer has no chat template')
+        msgs = [{"role": "user", "content": self.SENTINEL}]
+        kw = {"enable_thinking": False} if "enable_thinking" in tok.chat_template else {}
+        s = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, **kw)
+        head, tail = s.split(self.SENTINEL)
+        for opened, closed in (("<think>\n", "</think>\n\n"), ("<think>", "</think>\n\n"), ("<|channel>thought\n", "<channel|>")):
+            if tail.endswith(opened):
+                tail += closed
+        self.head_text, self.tail_text = head, tail
+        self.head = tok.encode(head, add_special_tokens=False)
+        self.tail = tok.encode(tail, add_special_tokens=False)
+        self.answer = answer
+        names, ids, _ = label_table(tok)
+        pre = tok.encode(f"{answer}: (", add_special_tokens=False)
+        for n, i in list(zip(names, ids))[:NARROW]:
+            if tok.encode(f"{answer}: ({n}", add_special_tokens=False) != pre + [i]:
+                raise ValueError(f"chat layout: the label {n!r} does not tokenize as one token after {answer!r}: (")
+        if tok.encode(tail + f"{answer}: (", add_special_tokens=False) != self.tail + pre:
+            raise ValueError("chat layout: the chat template tail merges with the answer prefix")
+
+    def answer_ids(self, tok, k, multi):
+        """Token ids of answer piece k: "Answer: (" (or "Answer k: (" with several questions), later pieces after a newline."""
+        return tok.encode(f"{'' if k == 0 else chr(10)}{self.answer}{' ' + str(k + 1) if multi else ''}: (", add_special_tokens=False)
+
+
+_CHAT = {}
+
+
+def chat_template(tok):
+    """The ChatTemplate of a tokenizer, cached per tokenizer object."""
+    key = id(tok)
+    if key not in _CHAT:
+        _CHAT[key] = (tok, ChatTemplate(tok))           # keep tok alive so its id is not reused
+    return _CHAT[key][1]
+
+
+def chat_for(tok, cfg):
+    """The ChatTemplate to pass as `chat=` for a model with this decider_config.json, or None for a plain-layout model."""
+    return chat_template(tok) if resolve_layout(cfg) == "chat" else None
+
+
+def load_decider_config(path):
+    """decider_config.json of a model folder or a Hub repository id; {} when the model has none (a raw base model)."""
+    import json, os
+    if os.path.isdir(path):
+        f = os.path.join(path, "decider_config.json")
+        return json.load(open(f)) if os.path.exists(f) else {}
+    try:
+        from huggingface_hub import hf_hub_download
+        return json.load(open(hf_hub_download(path, "decider_config.json")))
+    except Exception:
+        return {}
+
+
+def chat_for_model(path, tok):
+    """chat_for(tok, the model's decider_config.json): what every script that builds prompts for `path` passes as `chat=`."""
+    return chat_for(tok, load_decider_config(path))
+
+
+def build_chat(example, tok, chat, rng=None, max_options=NARROW, max_ctx_tokens=1536):
+    """State-first chat layout (see the comment above LAYOUTS).  Same return fields as `build`.  max_ctx_tokens caps the
+    tokens of "Context:\\n" + state, as in the plain layout; the template head and tail are not counted."""
+    rng = rng or random
+    qs = example.qs; multi = len(qs) > 1
+    ids = list(chat.head) + tok.encode("Context:\n" + example.context, add_special_tokens=False)[:max_ctx_tokens]
+    golds, nopts, perms = [], [], []
+    for k, q in enumerate(qs):
+        opts = _select(q, rng, max_options)
+        ids += tok.encode(f"\n\nQuestion{' ' + str(k + 1) if multi else ''}: {q.text}\nOptions:", add_special_tokens=False) + _options_ids(tok, q, opts)
+        golds.append(opts.index(q.gold) if q.gold in opts else -1); nopts.append(len(opts)); perms.append(opts)
+    ids += chat.tail
+    slots = []
+    for k in range(len(qs)):
+        ids += chat.answer_ids(tok, k, multi); slots.append(len(ids) - 1)
+    return dict(ids=ids, slots=slots, golds=golds, nopts=nopts, perms=perms)
+
+
+def letter_ids(tok):
+    ids = label_table(tok)[1]
+    for j, L in enumerate(LETTERS):
+        assert tok.encode(L, add_special_tokens=False) == [ids[j]], L
+    return ids
+
+
+def render(example, tok, **kw):
+    b = build(example, tok, **kw)
+    return tok.decode(b["ids"])

decider/systemone.py

@@ -0,0 +1,199 @@
+"""Jev-shaped requests on top of the decider prompt format (same wire format as TypeSafe's POST /v1/systemone).
+
+    state      str | dict | list            JSON state is serialised compactly; questions may name a part by path (`ticket.messages[0].text`)
+    questions  {id: {"type": "choice", "instructions": ..., "criteria": {name: description | {...} | [...] | None}}      up to 255 options
+                     {"type": "score",  "instructions": ..., "criteria": [level 0 description, level 1 description, ...]}  2..10 levels
+                     {"type": "noul",   "instructions": ... (optional), "criteria": {"true": ..., "false": ...} (optional)}}
+    a noul question needs instructions or at least one true/false description.
+    ids are never shown to the model.  `instructions` and every description may be a string or any JSON value.
+"""
+import json, math
+
+MAX_CHOICE, MAX_LEVELS = 255, 10
+
+
+def _txt(v):
+    return v if isinstance(v, str) else json.dumps(v, ensure_ascii=False)
+
+
+ANNOTATE_MIN = 8
+
+
+def annotate_indices(x, min_len=ANNOTATE_MIN):
+    """Write each element's position into long arrays ({"_index": i, ...}).  A path such as `records[47].text` otherwise makes
+    the model count 47 elements; with the index written down it is a lookup (json_k64 probe: 0.49 -> 0.57 accuracy)."""
+    if isinstance(x, list):
+        if len(x) >= min_len:
+            return [({"_index": i, **annotate_indices(v, min_len)} if isinstance(v, dict) else {"_index": i, "value": annotate_indices(v, min_len)}) for i, v in enumerate(x)]
+        return [annotate_indices(v, min_len) for v in x]
+    if isinstance(x, dict):
+        return {k: annotate_indices(v, min_len) for k, v in x.items()}
+    return x
+
+
+def render_state(state, index_arrays=True):
+    if isinstance(state, str):
+        return state
+    return json.dumps(annotate_indices(state) if index_arrays else state, ensure_ascii=False)
+
+
+def render_question(spec):
+    """-> dict(question=str, options=[str], type=..., names=[...])  (names: what the answer reports for each option)"""
+    t = spec.get("type", "choice"); crit = spec.get("criteria", spec.get("options"))
+    raw = spec.get("instructions", spec.get("question", ""))
+    if t in ("noul", "bool") and raw in (None, ""):          # the criteria carry the question (NOUL_WITHOUT_INSTRUCTIONS)
+        ins = NOUL_WITHOUT_INSTRUCTIONS
+        described = isinstance(crit, dict) and any(d not in (None, "") for d in (crit.get("true", crit.get(True)), crit.get("false", crit.get(False))))
+        if not described and (crit is None or isinstance(crit, dict)):     # a non-map is rejected below with the criteria message
+            raise ValueError("noul question without instructions: criteria must describe true or false")
+    else:
+        ins = _txt(raw)
+    if not ins:
+        raise ValueError("question without instructions")
+    if t == "choice":
+        if isinstance(crit, (list, tuple)):
+            crit = {str(c): None for c in crit}
+        if not isinstance(crit, dict) or not 2 <= len(crit) <= MAX_CHOICE:
+            raise ValueError(f"choice criteria: a map of 2..{MAX_CHOICE} options")
+        names = list(crit); opts = [n if crit[n] in (None, "") else f"{n}: {_txt(crit[n])}" for n in names]
+    elif t == "score":
+        if isinstance(crit, dict):                                   # legend form {"0": "...", "1": "..."}
+            crit = [crit[k] for k in sorted(crit, key=float)]
+        if not isinstance(crit, (list, tuple)) or not 2 <= len(crit) <= MAX_LEVELS:
+            raise ValueError(f"score criteria: an ordered list of 2..{MAX_LEVELS} level descriptions")
+        names = list(range(len(crit))); opts = [f"{i}: {_txt(c)}" for i, c in enumerate(crit)]
+    elif t in ("noul", "bool"):
+        if crit is not None and not isinstance(crit, dict):
+            raise ValueError("noul criteria: a map of optional true/false descriptions")
+        names = [False, True]; c = crit if crit is not None else {}
+        f, tr = c.get("false", c.get(False)), c.get("true", c.get(True))
+        opts = ["no" if f in (None, "") else f"no: {_txt(f)}", "yes" if tr in (None, "") else f"yes: {_txt(tr)}"]
+    else:
+        raise ValueError(f"unknown question type {t!r}")
+    return dict(question=ins, options=opts, type="noul" if t == "bool" else t, names=names, legend=[_txt(c) for c in crit] if t == "score" else None,
+                isolated=bool(spec.get("isolated", True)))
+
+
+# A noul question may omit `instructions` (TypeSafe's OpenAPI file marks it optional).  The question id is never shown to the
+# model, so the question text is this fixed sentence and the true/false descriptions, rendered as the options "no: ..." and
+# "yes: ...", say what is being asked.  A request that gives instructions is rendered exactly as before.
+NOUL_WITHOUT_INSTRUCTIONS = "Which answer fits the context?"
+
+
+# ---- isolated levels: every Score level is judged in its own row, without its number or its neighbours
+ISOLATED = "{q}\nProposed answer: {level}\nDoes the proposed answer fit?"
+_NUM = None
+
+
+def strip_level_number(text):
+    """"2: somewhat" -> "somewhat" (dataset legends carry the number; an isolated level must not)."""
+    import re
+    return re.sub(r"^\s*-?\d+\s*:\s*", "", text)
+
+
+def isolated_rows(question, levels):
+    """-> one yes/no question per level: [(question text, ["no", "yes"])]."""
+    return [(ISOLATED.format(q=question, level=strip_level_number(l)), ["no", "yes"]) for l in levels]
+
+
+def combine_isolated(p_yes):
+    """Per-level P(fits), each computed without reference to any other level -> a distribution over levels.
+    Also returns the unnormalised mass: near 1 when exactly one level fits, low when none does, high when several do."""
+    tot = sum(p_yes) or 1e-9
+    return [x / tot for x in p_yes], tot
+
+
+def plan_rows(rqs, isolated=True):
+    """One scoring row per question; a Score question with isolated levels becomes one yes/no row per level.
+    -> (rows [{"question", "options"}], index [(id, "iso" | "list", first row, n rows)])"""
+    rows, index = [], []
+    for k, r in rqs.items():
+        if isolated and r["type"] == "score" and r.get("isolated", True):
+            rws = isolated_rows(r["question"], r["legend"]); index.append((k, "iso", len(rows), len(rws))); rows += [dict(question=t, options=o) for t, o in rws]
+        else:
+            index.append((k, "list", len(rows), 1)); rows.append(dict(question=r["question"], options=r["options"]))
+    return rows, index
+
+
+def row_types(rqs, index):
+    """The answer type ("choice", "noul" or "score") of every plan_rows row, in row order.  An isolated Score question's
+    yes/no level rows carry "score": together they are one Score answer (decider.temperature)."""
+    types = [None] * sum(n for _, _, _, n in index)
+    for k, _, s, n in index:
+        types[s:s + n] = [rqs[k]["type"]] * n
+    return types
+
+
+def assemble(rqs, index, probs):
+    """probs: one probability list per row (plan_rows order) -> {id: answer}."""
+    out = {}
+    for k, kind, s, n in index:
+        if kind == "iso":
+            fit = [float(probs[s + j][1]) for j in range(n)]; p, mass = combine_isolated(fit); a = format_answer(rqs[k], p)
+            a["level_fit"] = {str(j): round(x, 4) for j, x in enumerate(fit)}; a["fit_mass"] = round(mass, 4); out[k] = a
+        else:
+            out[k] = format_answer(rqs[k], probs[s])
+    return out
+
+
+def certainty(p):
+    """1 - normalised entropy: 1 when all mass is on one option, 0 when the distribution is flat."""
+    h = -sum(x * math.log(x) for x in p if x > 0)
+    return max(0.0, 1.0 - h / math.log(len(p))) if len(p) > 1 else 1.0
+
+
+def _clip01(x):
+    return min(1.0, max(0.0, x))
+
+
+def _normalised(p):
+    """As the adapter's _normalize: a distribution with zero total counts as uniform."""
+    tot = sum(p)
+    return [1.0 / len(p)] * len(p) if tot == 0 else [x / tot for x in p]
+
+
+def choice_confidence(p):
+    """TypeSafe's Choice confidence: the largest probability rescaled so that a uniform distribution gives 0 and all mass on one
+    option gives 1, (n * p_max - 1) / (n - 1); 1 for a single option."""
+    n = len(p); p = _normalised(p)
+    return 1.0 if n <= 1 else _clip01((n * max(p) - 1) / (n - 1))
+
+
+def score_confidence(p):
+    """TypeSafe's Score confidence (system-one-adapter-python, confidence_metrics.score_confidence): 1 minus the expected distance
+    from the most likely level, divided by D = mean over levels i of |i - (n - 1)/2| (the mean distance of the levels from the
+    middle of the scale), floored at 0; 1 for a single level.
+    With two levels it equals choice_confidence."""
+    n = len(p); p = _normalised(p)
+    if n <= 1:
+        return 1.0
+    k = max(range(n), key=p.__getitem__)
+    spread = sum(x * abs(i - k) for i, x in enumerate(p))
+    uniform = sum(abs(i - (n - 1) / 2) for i in range(n)) / n
+    return _clip01(1.0 - spread / uniform)
+
+
+def format_answer(rq, p, nd=4):
+    """rq: render_question output; p: probabilities in option order.
+    `confidence` is TypeSafe's (choice_confidence / score_confidence); `x_p_max` is the largest probability, which was
+    `confidence` before 1.3.0."""
+    p = [float(x) for x in p[:len(rq["options"])]]; s = sum(p) or 1.0; p = [x / s for x in p]
+    j = max(range(len(p)), key=p.__getitem__)
+    if rq["type"] == "noul":
+        return {"type": "noul", "noul": round(p[1], nd)}
+    if rq["type"] == "choice":
+        return {"type": "choice", "choice": rq["names"][j], "confidence": round(choice_confidence(p), nd), "x_p_max": round(p[j], nd),
+                "certainty": round(certainty(p), nd), "probabilities": {n: round(x, nd) for n, x in zip(rq["names"], p)}}
+    return {"type": "score", "score": round(sum(i * x for i, x in enumerate(p)), 2), "confidence": round(score_confidence(p), nd), "x_p_max": round(p[j], nd),
+            "certainty": round(certainty(p), nd),
+            "legend": {str(i): d for i, d in enumerate(rq["legend"])}, "probabilities": {str(i): round(x, nd) for i, x in enumerate(p)}}
+
+
+def unique_tokens(items):
+    """Input tokens of a request whose rows share a prefix (the state): the prefix counts once."""
+    ids = [it["ids"] for it in items]
+    if len(ids) < 2:
+        return sum(len(x) for x in ids)
+    lcp = 0; short = min(len(x) for x in ids)
+    while lcp < short and all(x[lcp] == ids[0][lcp] for x in ids): lcp += 1
+    return lcp + sum(len(x) - lcp for x in ids)

decider/temperature.py

@@ -0,0 +1,144 @@
+"""Answer temperatures from decider_config.json (1.4.0).
+
+Every answer is softmax(logits / T) over its option letters.  decider_config.json sets T:
+
+    "temperature": 1.3                                   one value for every answer (the only form before 1.4.0)
+    "temperature_by_type": {"choice": 1.48, "noul": 2.22, "score": 1.38}
+                                                         optional; one value per answer type, a missing type uses "temperature"
+    "temperature_schema_first": 1.18                     optional; the schema cache (questions-first layout), as before
+    "temperature_schema_first_by_type": {...}            optional; per answer type on the schema cache
+
+The answer types are the /v1/systemone question types.  A /decide field maps onto them: "choice" -> "choice", "bool" -> "noul",
+"scale" -> "score".  Plain `Decider.decide` questions (a question and its options, no type) are "choice".  A Score question
+read with isolated levels (one yes/no row per level) uses the "score" temperature on every one of its level rows: the rows form
+one Score answer, and a temperature fitted on Score answers is fitted through that same readout (decider.calibrate).
+
+On the state-first layout the temperature of an answer of type t is temperature_by_type[t], else temperature.  On the schema
+cache it is temperature_schema_first_by_type[t], else temperature_schema_first, else (no schema-first value at all) the
+state-first temperature of t.  An explicit override (Decider(temperature=...), DECIDER_TEMPERATURE) replaces the state-first
+"temperature" and switches temperature_by_type off, so the override is the one temperature of every state-first answer, as it
+was before 1.4.0.
+
+A config without a by-type map gives every path the single number it gave in 1.3.0, and that number reaches the engines as the
+same Python float, so the probabilities are bit-identical to 1.3.0.
+"""
+import math
+
+TYPES = ("choice", "noul", "score")
+FIELD_TYPES = {"choice": "choice", "bool": "noul", "scale": "score"}        # /decide field type -> answer type
+_KEYS_TEXT = ('the keys are "choice", "noul" and "score" (a /decide "bool" field is "noul", a "scale" field is "score"; '
+              'a /v1/systemone "bool" question is "noul")')
+
+
+def positive(value, where):
+    """A temperature: a number (or a numeric string, as float() reads it, which 1.3.0 accepted for "temperature") that is finite
+    and > 0.  Raises ValueError naming `where`."""
+    if isinstance(value, bool):
+        raise ValueError(f"{where} must be a finite number > 0, got {value!r}")
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        raise ValueError(f"{where} must be a finite number > 0, got {value!r}") from None
+    if not math.isfinite(v) or v <= 0:
+        raise ValueError(f"{where} must be a finite number > 0, got {value!r}")
+    return v
+
+
+def by_type(m, where):
+    """Validate a {answer type: temperature} map.  None -> {}.  Unknown keys, non-numbers and values that are not finite and > 0
+    raise ValueError."""
+    if m is None:
+        return {}
+    if not isinstance(m, dict):
+        raise ValueError(f"{where} must be a map {{answer type: temperature}}, got {type(m).__name__}; " + _KEYS_TEXT)
+    out = {}
+    for k, v in m.items():
+        if k not in TYPES:
+            raise ValueError(f"{where} has the unknown key {k!r}; " + _KEYS_TEXT)
+        if isinstance(v, bool) or not isinstance(v, (int, float)):
+            raise ValueError(f"{where}[{k!r}] must be a finite number > 0, got {v!r}")
+        out[k] = positive(v, f"{where}[{k!r}]")
+    return out
+
+
+def from_config(cfg, temperature=None, temperature_by_type=None):
+    """-> ((T, by_type) for the state-first layout, (T, by_type) for the schema cache).
+
+    temperature / temperature_by_type: explicit overrides (Decider arguments, DECIDER_TEMPERATURE).  An explicit temperature
+    without an explicit map switches the config's map off (see the module docstring)."""
+    cfg = cfg or {}
+    where = "decider_config.json"
+    if temperature is not None:
+        T = positive(temperature, "temperature")
+        m = by_type(temperature_by_type, "temperature_by_type") if temperature_by_type is not None else {}
+    else:
+        T = positive(cfg.get("temperature", 1.0), f'{where} "temperature"')
+        m = (by_type(temperature_by_type, "temperature_by_type") if temperature_by_type is not None
+             else by_type(cfg.get("temperature_by_type"), f'{where} "temperature_by_type"'))
+    ms = by_type(cfg.get("temperature_schema_first_by_type"), f'{where} "temperature_schema_first_by_type"')
+    if "temperature_schema_first" in cfg:
+        schema = (positive(cfg["temperature_schema_first"], f'{where} "temperature_schema_first"'), ms)
+    else:
+        schema = (T, {**m, **ms})
+    return (T, m), schema
+
+
+def effective(T, m):
+    """{answer type: the temperature it gets} for reporting (/health, the ready line)."""
+    return {t: m.get(t, T) for t in TYPES}
+
+
+def for_types(T, m, types):
+    """One temperature per slot, or the scalar T itself when there is no map (the 1.3.0 call)."""
+    if not m:
+        return T
+    return [m.get(t, T) for t in types]
+
+
+def item_types(it):
+    """The answer type of every slot of a prompt item ("types", set where the item is built); None for an item without it."""
+    ts = it.get("types")
+    return list(ts) if ts is not None else [None] * len(it["slots"])
+
+
+def for_items(T, m, items):
+    """The `temperature` argument of Engine.score_items / score_shared: the scalar T when there is no map (the 1.3.0 call),
+    else one list of per-slot temperatures per item."""
+    if not m:
+        return T
+    return [[m.get(t, T) for t in item_types(it)] for it in items]
+
+
+def slot_temperatures(temperature, items):
+    """Engine side.  temperature: a scalar (returned as it is), or one entry per item, each a scalar or one value per slot of
+    that item.  -> the scalar, or a flat list with one temperature per slot in item order."""
+    if not isinstance(temperature, (list, tuple)):
+        return temperature
+    if len(temperature) != len(items):
+        raise ValueError(f"temperature: {len(temperature)} entries for {len(items)} items")
+    flat = []
+    for t, it in zip(temperature, items):
+        n = len(it["slots"])
+        if isinstance(t, (list, tuple)):
+            if len(t) != n:
+                raise ValueError(f"temperature: {len(t)} values for an item with {n} slots")
+            flat += list(t)
+        else:
+            flat += [t] * n
+    return flat
+
+
+def item_slice(temperature, lo, hi):
+    """The per-item temperature entries of items[lo:hi] (a scalar is shared by every item)."""
+    return temperature[lo:hi] if isinstance(temperature, (list, tuple)) else temperature
+
+
+def scaled_softmax(lg, temperature):
+    """softmax(lg / T) over the last axis.  A scalar T is the 1.3.0 expression unchanged; a list gives one T per row of lg."""
+    import torch
+    if isinstance(temperature, (list, tuple)):
+        if len(temperature) != lg.shape[0]:
+            raise ValueError(f"temperature: {len(temperature)} values for {lg.shape[0]} slots")
+        t = torch.tensor(temperature, dtype=lg.dtype).to(lg.device, non_blocking=True)[:, None]
+        return torch.softmax(lg / t, -1)
+    return torch.softmax(lg / temperature, -1)

requirements.txt

@@ -1,7 +1,12 @@
 gradio>=5.0
+# transformers floor is set by Mapika/decider-4b (its Qwen3.5 linear-attention layers
+# need >=5.17.0). convaiinnovations/laya only requires >=4.48.0 with no upper bound, and
+# the laya authors' own ZeroGPU demo pins >=5.0, so one image can serve both backends.
+transformers>=5.17.0
 laya>=0.3.4
+accelerate
+flash-linear-attention
 torch>=2.0.0
-transformers>=4.45.0
 safetensors>=0.4.0
 huggingface_hub>=0.20.0
 numpy>=1.20.0