mlx-bun 0.0.11 → 0.0.13

package/src/ssd-cache.ts

@@ -42,10 +42,12 @@ export interface SsdIndexEntry {
 
 /** Trimmability from a file header alone (mirror of the live caches'
  *  isTrimmable(): kv/qkv/turboquant always trim; rotating kinds only pre-wrap
- *  (offset < maxSize); ssm never). Keep in sync with gemma4-base/qwen3-delta. */
+ *  (offset < maxSize); GLM compressed kinds always trim; ssm never). Keep in
+ *  sync with gemma4-base/qwen3-delta/glm52-cache. */
 const headerTrimmable = (caches: { kind: string; offset: number; maxSize?: number }[]): boolean =>
   caches.every((c) =>
-    c.kind === "kv" || c.kind === "qkv" || c.kind === "turboquant"
+    c.kind === "kv" || c.kind === "qkv" || c.kind === "turboquant" ||
+      c.kind === "mla" || c.kind === "mla-dsa" || c.kind === "mtp-mla"
       ? true
       : c.kind === "rotating" || c.kind === "rotating-qkv"
         ? c.offset < (c.maxSize ?? 0)
@@ -111,6 +113,7 @@ export class SsdCacheStore {
         try {
           const h = readKvHeader(path); // verifies the header hash
           if (
+            h.modelId !== this.#opts.modelId ||
             h.configFingerprint !== this.#opts.configFingerprint ||
             h.tokenizerHash !== this.#opts.tokenizerHash
           )
@@ -159,6 +162,7 @@ export class SsdCacheStore {
     const t0 = performance.now();
     try {
       const expect: KvLoadExpect = {
+        modelId: this.#opts.modelId,
         configFingerprint: this.#opts.configFingerprint,
         tokenizerHash: this.#opts.tokenizerHash,
         ns: entry.ns,

package/src/tool-call.ts

@@ -162,6 +162,8 @@ export function parseToolCalls(text: string): ParsedToolCall[] {
 const TOOL_CALL_BLOCK_RE = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gi;
 const XML_FUNCTION_EQUALS_RE = /^\s*<function=([^>\s]+)>\s*([\s\S]*?)\s*<\/function>\s*$/i;
 const XML_PARAMETER_EQUALS_RE = /<parameter=([^>\s]+)>\s*([\s\S]*?)\s*<\/parameter>/gi;
+const GLM52_ARG_KEY_RE = /<arg_key>/i;
+const GLM52_ARG_PAIR_RE = /<arg_key>\s*([\s\S]*?)\s*<\/arg_key>\s*<arg_value>\s*([\s\S]*?)\s*<\/arg_value>/gi;
 const XML_FUNCTION_ATTR_RE = /<function\s+name=["']([^"']+)["']\s*>\s*([\s\S]*?)\s*<\/function>/gi;
 // CDATA alternative first so a `</param>` inside a CDATA block never
 // terminates the value early.
@@ -560,6 +562,29 @@ function parseXmlEqualsToolCall(block: string, tools: ToolSpec[]): ParsedToolCal
   return { name, arguments: args };
 }
 
+function parseGlm52ToolCall(block: string, tools: ToolSpec[]): ParsedToolCall | null {
+  const firstArg = block.search(GLM52_ARG_KEY_RE);
+  const name = (firstArg < 0 ? block : block.slice(0, firstArg)).trim();
+  if (!name || !/^[^\s<>]+$/.test(name)) return null;
+  if (firstArg < 0) return { name, arguments: {} };
+
+  const body = block.slice(firstArg);
+  const args: Record<string, unknown> = {};
+  let cursor = 0;
+  let matched = false;
+  for (const pair of body.matchAll(GLM52_ARG_PAIR_RE)) {
+    if (body.slice(cursor, pair.index).trim()) return null;
+    const key = pair[1]!.trim();
+    if (!key) throw new Error(`tool '${name}' contains an empty argument name`);
+    args[key] = decodeToolValue(pair[2]!, toolParameterSchema(tools, name, key));
+    cursor = pair.index + pair[0].length;
+    matched = true;
+  }
+  GLM52_ARG_PAIR_RE.lastIndex = 0;
+  if (!matched || body.slice(cursor).trim()) return null;
+  return { name, arguments: args };
+}
+
 function parseXmlAttrToolCalls(text: string, tools: ToolSpec[]): ParsedToolCall[] {
   const calls: ParsedToolCall[] = [];
   for (const fn of text.matchAll(XML_FUNCTION_ATTR_RE)) {
@@ -582,7 +607,8 @@ function parseXmlAttrToolCalls(text: string, tools: ToolSpec[]): ParsedToolCall[
  *  after generation, and only when tools are active; tokenizer ids are
  *  model-family-specific and must not be used globally. Supports the
  *  OpenAI JSON `<tool_call>...</tool_call>` contract, Qwen-style
- *  `<function=name><parameter=...>`, and MiniCPM5's native
+ *  `<function=name><parameter=...>`, GLM-5.2's
+ *  `name<arg_key>...<arg_value>...`, and MiniCPM5's native
  *  `<function name="..."><param name="...">...` template shape. */
 export function parseGeneratedToolCalls(text: string, tools: ToolSpec[]): ParsedToolCall[] {
   if (!tools.length) return [];
@@ -590,7 +616,9 @@ export function parseGeneratedToolCalls(text: string, tools: ToolSpec[]): Parsed
   const calls: ParsedToolCall[] = [];
   for (const block of text.matchAll(TOOL_CALL_BLOCK_RE)) {
     const body = block[1]!.trim();
-    const parsed = parseJsonToolCall(body) ?? parseXmlEqualsToolCall(body, tools);
+    const parsed = parseJsonToolCall(body) ??
+      parseXmlEqualsToolCall(body, tools) ??
+      parseGlm52ToolCall(body, tools);
     if (!parsed) throw new Error("unsupported tool_call payload format");
     calls.push(parsed);
   }

package/src/train/job.ts

@@ -123,16 +123,6 @@ function parseConfig(raw: Record<string, unknown>): { modelDir: string; dataDir:
 export const finetuneRunner: JobRunner = async (emit, config) => {
   const { modelDir, dataDir, cfg } = parseConfig(config);
 
-  // Gemma/e4b needs these training env flags set BEFORE the model loads — same
-  // as the `mlx-bun train` CLI. The subprocess job path doesn't inherit them
-  // from the server, so without this a web-submitted ORPO/SFT run on Gemma uses
-  // the wrong kernels. ??= so an explicit env (or the CLI) still wins.
-  try {
-    const isGemma = (await Bun.file(`${modelDir}/config.json`).text()).toLowerCase().includes("gemma");
-    if (isGemma) {
-    }
-  } catch {}
-
   emit({ type: "stage", stage: "load", progress: 0.01, message: `loading model ${modelDir}` });
 
   const { loadModelConfig } = await import("../config");

package/src/train/lora-params.ts

@@ -165,15 +165,21 @@ export interface SaveAdapterConfig {
   rsLora?: boolean;
 }
 
+export interface SaveAdapterOptions {
+  /** Override config-file writes for deterministic durability tests. */
+  writeFile?: (path: string, data: string) => Promise<unknown>;
+}
+
 /** Save the trained adapter into `dir` in the AdapterManager.mount format:
  *  adapters.safetensors (lora_a / lora_b tensor names), optiq_lora_config.json,
  *  and a PEFT-compatible adapter_config.json. */
-export function saveAdapter(
+export async function saveAdapter(
   lora: TrainableLora,
   dir: string,
   cfg: SaveAdapterConfig,
   appliedRanks: Record<string, number>,
-): void {
+  options: SaveAdapterOptions = {},
+): Promise<void> {
   mkdirSync(dir, { recursive: true });
 
   // Build the native string→array map and insert lora_a / lora_b per target.
@@ -211,8 +217,6 @@ export function saveAdapter(
     applied_ranks: appliedRanks,
     source_model: cfg.baseModel,
   };
-  Bun.write(`${dir}/optiq_lora_config.json`, JSON.stringify(optiqCfg, null, 2) + "\n");
-
   // PEFT-compatible adapter_config.json (loadable by mlx-lm / PEFT).
   const peftCfg = {
     fine_tune_type: "lora",
@@ -223,15 +227,22 @@ export function saveAdapter(
     fan_in_fan_out: false,
     inference_mode: false,
     init_lora_weights: true,
-    lora_alpha: Math.round(cfg.rank * cfg.scale),
+    // mlx-bun's `scale` is the numerator before rsLoRA's √rank division.
+    // Ordinary PEFT needs alpha/r = scale; rsLoRA needs alpha/√r = scale/√r.
+    lora_alpha: cfg.rsLora ? cfg.scale : Math.round(cfg.rank * cfg.scale),
     lora_dropout: 0.0,
     peft_type: "LORA",
     r: cfg.rank,
     target_modules: cfg.targetModules,
     task_type: "CAUSAL_LM",
+    use_rslora: cfg.rsLora ?? false,
     optiq: { rank_scaling: cfg.rankScaling, applied_ranks: appliedRanks },
   };
-  Bun.write(`${dir}/adapter_config.json`, JSON.stringify(peftCfg, null, 2) + "\n");
+  const writeFile = options.writeFile ?? ((path: string, data: string) => Bun.write(path, data));
+  await Promise.all([
+    writeFile(`${dir}/optiq_lora_config.json`, JSON.stringify(optiqCfg, null, 2) + "\n"),
+    writeFile(`${dir}/adapter_config.json`, JSON.stringify(peftCfg, null, 2) + "\n"),
+  ]);
 }
 
 /** Dispose all trainable leaves (frees A/B). */

package/src/train/trainer.ts

@@ -202,6 +202,51 @@ export const DEFAULT_TRAIN_CONFIG: TrainConfig = {
   baseModel: "",
 };
 
+/** Build the per-leaf LoRA+ LR multipliers for flatParams' stable
+ *  `[...A, ...B]` order. `undefined` keeps AdamW's uniform-LR fast path. */
+export function loraPlusLrScale(
+  paramCount: number,
+  targetCount: number,
+  ratio: number,
+): number[] | undefined {
+  if (!Number.isFinite(ratio) || ratio < 1)
+    throw new RangeError(`loraPlusRatio must be a finite number >= 1 (got ${ratio})`);
+  if (paramCount !== targetCount * 2)
+    throw new Error(
+      `LoRA+ expected ${targetCount * 2} A/B leaves for ${targetCount} targets, got ${paramCount}`,
+    );
+  if (ratio === 1) return undefined;
+  return Array.from({ length: paramCount }, (_, i) => (i < targetCount ? 1 : ratio));
+}
+
+/** One optimizer policy for SFT, DPO, and ORPO. Keeping LoRA+ here prevents a
+ *  method-specific loop from silently accepting the knob without applying it. */
+function createLoraOptimizer(
+  params: MlxArray[],
+  lora: TrainableLora,
+  cfg: TrainConfig,
+  emit: Emit,
+): AdamW {
+  const lrScale = loraPlusLrScale(params.length, lora.targets.length, cfg.loraPlusRatio);
+  if (lrScale) emit({
+    type: "stage",
+    stage: "setup",
+    progress: 0.04,
+    message: `LoRA+ : B leaves at ${cfg.loraPlusRatio}× LR`,
+  });
+  return new AdamW(
+    params,
+    {
+      lr: cfg.learningRate,
+      betas: cfg.betas,
+      eps: 1e-8,
+      weightDecay: cfg.weightDecay,
+      lrScale,
+    },
+    (i, p) => writeParam(lora, i, p),
+  );
+}
+
 /** Run a LoRA fine-tune. Emits per-step train metrics, periodic val metrics,
  *  and a final stage:done with the adapter path + applied ranks. Saves the
  *  adapter (last + best-on-val) and returns where it landed. */
@@ -286,6 +331,7 @@ export async function trainLora(
   // weak proxy. Capture them when the loop emits them so metrics.json lets you
   // pick the best-MARGIN checkpoint (overfit shows as train↑ / val-margin flat).
   const valHistory: { step: number; loss: number; margin?: number; accuracy?: number; checkpoint: string | null }[] = [];
+  const checkpointSaves: Promise<void>[] = [];
   const startedAt = Date.now();
 
   // Live, append-only metrics stream (the source `mlx-bun train-watch` tails).
@@ -319,7 +365,11 @@ export async function trainLora(
       if (cfg.saveCheckpoints) {
         const tag = `step-${String(e.step).padStart(5, "0")}-val${e.loss.toFixed(4)}`;
         checkpoint = `${cfg.adapterPath}/checkpoints/${tag}`;
-        saveAdapter(lora, checkpoint, saveCfg, appliedRanks);
+        const save = saveAdapter(lora, checkpoint, saveCfg, appliedRanks);
+        checkpointSaves.push(save);
+        // Keep a handler attached while training continues. Promise.all below
+        // still surfaces the original rejection before the run can succeed.
+        void save.catch(() => {});
         emit({ type: "stage", stage: "checkpoint", progress: e.step / cfg.iters,
                message: `checkpoint ${tag}` });
       }
@@ -337,9 +387,11 @@ export async function trainLora(
           ? await orpoLoop(model, tok, tmpl, dataDir, cfg, lora, collect)
           : await sftLoop(model, tok, tmpl, dataDir, cfg, lora, collect);
 
+    await Promise.all(checkpointSaves);
+
     // Final save (last adapter).
     detachTraining(model, lora);
-    saveAdapter(lora, cfg.adapterPath, saveCfg, appliedRanks);
+    await saveAdapter(lora, cfg.adapterPath, saveCfg, appliedRanks);
 
     // Durable, structured run record alongside the adapter (only when we kept
     // checkpoints). Pick the best-val one for convenience, but ship ALL of them
@@ -415,11 +467,7 @@ async function sftLoop(
     : [];
 
   const params = flatParams(lora);
-  const opt = new AdamW(
-    params,
-    { lr: cfg.learningRate, betas: cfg.betas, eps: 1e-8, weightDecay: cfg.weightDecay },
-    (i, p) => writeParam(lora, i, p),
-  );
+  const opt = createLoraOptimizer(params, lora, cfg, emit);
 
   // Segmented backward: stream the SFT backward segment-by-segment (only one
   // segment's activations live at a time). Phase A is MiniCPM5 SFT B=1 only;
@@ -658,11 +706,7 @@ async function dpoLoop(
     : [];
 
   const params = flatParams(lora);
-  const opt = new AdamW(
-    params,
-    { lr: cfg.learningRate, betas: cfg.betas, eps: 1e-8, weightDecay: cfg.weightDecay },
-    (i, p) => writeParam(lora, i, p),
-  );
+  const opt = createLoraOptimizer(params, lora, cfg, emit);
 
   const schedule =
     cfg.dpoLrSchedule === "cosine" || cfg.dpoWarmupIters > 0
@@ -789,18 +833,7 @@ async function orpoLoop(
     : [];
 
   const params = flatParams(lora);
-  // LoRA+: B leaves (the second half of flatParams) get a higher LR than A.
-  const nT = lora.targets.length;
-  const lrScale = cfg.loraPlusRatio !== 1
-    ? params.map((_, i) => (i < nT ? 1 : cfg.loraPlusRatio))
-    : undefined;
-  if (lrScale) emit({ type: "stage", stage: "setup", progress: 0.04,
-    message: `LoRA+ : B leaves at ${cfg.loraPlusRatio}× LR` });
-  const opt = new AdamW(
-    params,
-    { lr: cfg.learningRate, betas: cfg.betas, eps: 1e-8, weightDecay: cfg.weightDecay, lrScale },
-    (i, p) => writeParam(lora, i, p),
-  );
+  const opt = createLoraOptimizer(params, lora, cfg, emit);
 
   const schedule =
     cfg.orpoLrSchedule === "cosine" || cfg.orpoWarmupIters > 0
@@ -1172,11 +1205,11 @@ function clipGradsByNorm(grads: MlxArray[], normVal: number, maxNorm: number): v
 
 /** Supervised (response) tokens across ALL rows of the batch — the count
  *  tokens/sec is reported over (mlx-lm's n_tokens counts every row too). */
-function countResponseTokens(batch: SftBatch): number {
+export function countResponseTokens(batch: SftBatch): number {
   let total = 0;
   for (let r = 0; r < batch.ids.length; r++) {
     const promptLen = batch.promptLens[r]!;
-    const len = batch.ids[r]!.length;
+    const len = rowLength(batch, r);
     total += Math.max(0, len - Math.max(promptLen, 1));
   }
   return total;

package/src/web/app.html

@@ -2027,6 +2027,14 @@
             <div class="kv"><b>mode</b><span id="st-kv-mode">—</span></div>
             <div id="st-kv-layers"></div>
           </div>
+          <div class="card" id="st-glm-expert-card" style="display:none">
+            <h3>GLM expert tiers · last turn</h3>
+            <div class="kv"><b>main cache hit</b><span class="num" id="st-glm-main-hit">—</span></div>
+            <div class="kv"><b>main SSD read</b><span class="num" id="st-glm-main-read">—</span></div>
+            <div class="kv"><b>MTP cache hit</b><span class="num" id="st-glm-mtp-hit">—</span></div>
+            <div class="kv"><b>MTP SSD read</b><span class="num" id="st-glm-mtp-read">—</span></div>
+            <div class="cap" id="st-glm-residency">waiting for the first completed turn</div>
+          </div>
           <div class="card" id="st-dl-card" style="grid-column:1 / -1;display:none">
             <h3>Downloads</h3>
             <div id="st-dl-list"></div>
@@ -2057,9 +2065,12 @@
           </div>
           <div class="card">
             <h3>At max context · <span class="num" id="st-fit-ctx">—</span> tokens</h3>
-            <div class="kv"><b>weights</b><span class="num" id="st-f-weights">—</span></div>
+            <div class="kv" data-glm-fit style="display:none"><b>artifact on disk</b><span class="num" id="st-f-artifact">—</span></div>
+            <div class="kv"><b id="st-f-weights-label">weights</b><span class="num" id="st-f-weights">—</span></div>
+            <div class="kv" data-glm-fit style="display:none"><b>main expert slab</b><span class="num" id="st-f-main-slab">—</span></div>
+            <div class="kv" data-glm-fit style="display:none"><b>MTP expert slab</b><span class="num" id="st-f-mtp-slab">—</span></div>
             <div class="kv"><b>kv cache</b><span class="num" id="st-f-kv">—</span></div>
-            <div class="kv"><b>transient</b><span class="num" id="st-f-transient">—</span></div>
+            <div class="kv"><b id="st-f-transient-label">transient</b><span class="num" id="st-f-transient">—</span></div>
             <div class="kv"><b>total / usable</b><span class="num" id="st-f-total">—</span></div>
             <div class="meter"><i id="st-fit-bar"></i></div>
           </div>

package/src/web/app.js

@@ -4791,6 +4791,24 @@ function createStatusController() {
       $("st-kv-mode").innerHTML = "<code>" + esc(kv.mode || "—") + "</code>";
       const att = kv.attention;
       $("st-kv-layers").innerHTML = Object.entries(kv.layers || {}).map(([k, v]) => '<div class="kv"><b>' + esc(k) + ' layers</b><span class="num">' + esc(v) + "</span></div>").join("") + (att ? '<div class="kv"><b>attention</b><span class="num">' + esc(att.global) + " global · " + esc(att.sliding_window) + " sliding</span></div>" : "");
+      const glm = stats.glm52;
+      const expert = glm && glm.expert_runtime;
+      const expertCard = $("st-glm-expert-card");
+      expertCard.style.display = glm ? "" : "none";
+      if (glm) {
+        const rate = (d) => {
+          const total = (d?.hits || 0) + (d?.misses || 0);
+          return total ? (100 * (d?.hits || 0) / total).toFixed(1) + "%" : "—";
+        };
+        const turn = expert && expert.last_turn;
+        $("st-glm-main-hit").textContent = rate(turn?.main?.demand);
+        $("st-glm-main-read").textContent = turn?.main?.demand ? gb(turn.main.demand.readBytes) : "—";
+        $("st-glm-mtp-hit").textContent = rate(turn?.mtp?.demand);
+        $("st-glm-mtp-read").textContent = turn?.mtp?.demand ? gb(turn.mtp.demand.readBytes) : "—";
+        const main = expert?.main_residency;
+        const mtp = expert?.mtp_residency;
+        $("st-glm-residency").textContent = main ? "resident slots main " + num(main.resident + main.pinned) + " / " + num(main.resident + main.pinned + main.working) + (mtp ? " · MTP " + num(mtp.resident + mtp.pinned) + " / " + num(mtp.resident + mtp.pinned + mtp.working) : "") : "expert runtime telemetry unavailable";
+      }
       await loadDownloads();
       if (!fitLoaded) {
         await loadFit();
@@ -4872,10 +4890,11 @@ function createStatusController() {
     }
     fitLoaded = true;
     const r = f.report || {};
+    const tps = (value) => value < 1 ? value.toFixed(2) : value.toFixed(1);
     if (f.measured_decode_tps) {
-      $("st-tps").textContent = f.measured_decode_tps.toFixed(1);
+      $("st-tps").textContent = tps(f.measured_decode_tps);
       $("st-tps").closest(".card").querySelector("h3").textContent = "Decode · measured";
-      $("st-tps-cap").textContent = "mlx-bun benchmark on this machine · predicted " + (f.typical_decode_tps || 0).toFixed(1) + " at " + num(f.typical_context_tokens) + " ctx";
+      $("st-tps-cap").textContent = f.glm52 ? "quality-preserving warm · direct oracle " + tps(f.glm52.direct_oracle_warm_decode_tps || 0) + " · aspiration " + tps(f.glm52.aspirational_decode_tps || 0) : "mlx-bun benchmark on this machine · predicted " + tps(f.typical_decode_tps || 0) + " at " + num(f.typical_context_tokens) + " ctx";
     } else if (f.typical_decode_tps) {
       $("st-tps").textContent = f.typical_decode_tps.toFixed(1);
       $("st-tps-cap").textContent = "at " + num(f.typical_context_tokens) + " context · " + (r.predicted_decode_tps || 0).toFixed(1) + " tok/s at the " + num(f.context_tokens) + " max (full-KV reads)";
@@ -4886,6 +4905,14 @@ function createStatusController() {
     $("st-m-bw").textContent = (f.machine && f.machine.bandwidth_gbs || "—") + " GB/s";
     $("st-m-fits").innerHTML = r.fits ? '<span style="color:var(--green);font-weight:700">FITS</span>' : '<span style="color:var(--red);font-weight:700">DOES NOT FIT</span>';
     $("st-fit-ctx").textContent = num(f.context_tokens);
+    document.querySelectorAll("[data-glm-fit]").forEach((row) => {
+      row.style.display = f.glm52 ? "" : "none";
+    });
+    $("st-f-weights-label").textContent = f.glm52 ? "resident weights" : "weights";
+    $("st-f-transient-label").textContent = f.glm52 ? "other reserves" : "transient";
+    $("st-f-artifact").textContent = f.glm52?.artifact_disk_bytes ? gb(f.glm52.artifact_disk_bytes) : "registry unavailable";
+    $("st-f-main-slab").textContent = gb(f.glm52?.main_expert_slab_bytes);
+    $("st-f-mtp-slab").textContent = gb(f.glm52?.mtp_expert_slab_bytes);
     $("st-f-weights").textContent = gb(r.weights_bytes);
     $("st-f-kv").textContent = gb(r.kv_bytes);
     $("st-f-transient").textContent = gb(r.transient_bytes);
@@ -4910,7 +4937,7 @@ function createStatusController() {
     $("st-sku-body").innerHTML = rows.map((row, i) => {
       const you = i === youIdx;
       const dimCls = row.fits ? "num" : "num fit-no";
-      return "<tr" + (you ? ' class="you"' : "") + "><td>" + esc(row.sku) + (you ? " · <b>this machine</b>" : "") + '</td><td class="num">' + row.ram_gb + " GB</td>" + '<td class="' + (row.fits ? "fit-yes" : "fit-no") + '">' + (row.fits ? "fits" : "no") + "</td>" + '<td class="' + dimCls + '">' + (row.max_context > 0 ? num(row.max_context) : "0 — weights alone don’t fit") + "</td>" + '<td class="' + dimCls + '">' + (row.decode_tps > 0 ? "~" + row.decode_tps.toFixed(0) + " tok/s" : "—") + "</td></tr>";
+      return "<tr" + (you ? ' class="you"' : "") + "><td>" + esc(row.sku) + (you ? " · <b>this machine</b>" : "") + '</td><td class="num">' + row.ram_gb + " GB</td>" + '<td class="' + (row.fits ? "fit-yes" : "fit-no") + '">' + (row.fits ? "fits" : "no") + "</td>" + '<td class="' + dimCls + '">' + (row.max_context > 0 ? num(row.max_context) : "0 — weights alone don’t fit") + "</td>" + '<td class="' + dimCls + '">' + (row.decode_tps > 0 ? "~" + tps(row.decode_tps) + " tok/s" : "—") + "</td></tr>";
     }).join("");
   }
   return {

package/src/web/src/status.ts

@@ -90,6 +90,32 @@ export function createStatusController() {
         .map(([k, v]) => '<div class="kv"><b>' + esc(k) + ' layers</b><span class="num">' + esc(v) + "</span></div>").join("") +
         (att ? '<div class="kv"><b>attention</b><span class="num">' + esc(att.global) + " global · " + esc(att.sliding_window) + " sliding</span></div>" : "");
 
+      const glm = stats.glm52;
+      const expert = glm && glm.expert_runtime;
+      const expertCard = $("st-glm-expert-card");
+      expertCard.style.display = glm ? "" : "none";
+      if (glm) {
+        const rate = (d: { hits?: number; misses?: number } | null | undefined): string => {
+          const total = (d?.hits || 0) + (d?.misses || 0);
+          return total ? (100 * (d?.hits || 0) / total).toFixed(1) + "%" : "—";
+        };
+        const turn = expert && expert.last_turn;
+        $("st-glm-main-hit").textContent = rate(turn?.main?.demand);
+        $("st-glm-main-read").textContent = turn?.main?.demand
+          ? gb(turn.main.demand.readBytes) : "—";
+        $("st-glm-mtp-hit").textContent = rate(turn?.mtp?.demand);
+        $("st-glm-mtp-read").textContent = turn?.mtp?.demand
+          ? gb(turn.mtp.demand.readBytes) : "—";
+        const main = expert?.main_residency;
+        const mtp = expert?.mtp_residency;
+        $("st-glm-residency").textContent = main
+          ? "resident slots main " + num(main.resident + main.pinned) +
+            " / " + num(main.resident + main.pinned + main.working) +
+            (mtp ? " · MTP " + num(mtp.resident + mtp.pinned) +
+              " / " + num(mtp.resident + mtp.pinned + mtp.working) : "")
+          : "expert runtime telemetry unavailable";
+      }
+
       await loadDownloads();
       if (!fitLoaded) { await loadFit(); await loadLibrary(); }
       if (stats.server && stats.server.started_at) {
@@ -179,15 +205,28 @@ export function createStatusController() {
       machine?: { ram_bytes?: number; bandwidth_gbs?: number; chip?: string };
       sku_matrix_ctx?: number;
       sku_matrix?: SkuRow[];
+      glm52?: {
+        artifact_disk_bytes?: number | null;
+        main_expert_slab_bytes?: number;
+        mtp_expert_slab_bytes?: number;
+        direct_oracle_warm_decode_tps?: number;
+        aspirational_decode_tps?: number;
+      };
     }
     let f: FitResponse;
     try { f = await fetch("/fit").then((r) => r.json()); } catch { return; }
     fitLoaded = true;
     const r = f.report || {};
+    const tps = (value: number): string => value < 1 ? value.toFixed(2) : value.toFixed(1);
     if (f.measured_decode_tps) {
-      $("st-tps").textContent = f.measured_decode_tps.toFixed(1);
+      $("st-tps").textContent = tps(f.measured_decode_tps);
       $("st-tps").closest(".card")!.querySelector("h3")!.textContent = "Decode · measured";
-      $("st-tps-cap").textContent = "mlx-bun benchmark on this machine · predicted " + (f.typical_decode_tps || 0).toFixed(1) + " at " + num(f.typical_context_tokens) + " ctx";
+      $("st-tps-cap").textContent = f.glm52
+        ? "quality-preserving warm · direct oracle " +
+          tps(f.glm52.direct_oracle_warm_decode_tps || 0) +
+          " · aspiration " + tps(f.glm52.aspirational_decode_tps || 0)
+        : "mlx-bun benchmark on this machine · predicted " +
+          tps(f.typical_decode_tps || 0) + " at " + num(f.typical_context_tokens) + " ctx";
     } else if (f.typical_decode_tps) {
       $("st-tps").textContent = f.typical_decode_tps.toFixed(1);
       $("st-tps-cap").textContent = "at " + num(f.typical_context_tokens) + " context · " + (r.predicted_decode_tps || 0).toFixed(1) + " tok/s at the " + num(f.context_tokens) + " max (full-KV reads)";
@@ -198,6 +237,15 @@ export function createStatusController() {
     $("st-m-bw").textContent = (f.machine && f.machine.bandwidth_gbs || "—") + " GB/s";
     $("st-m-fits").innerHTML = r.fits ? '<span style="color:var(--green);font-weight:700">FITS</span>' : '<span style="color:var(--red);font-weight:700">DOES NOT FIT</span>';
     $("st-fit-ctx").textContent = num(f.context_tokens);
+    document.querySelectorAll<HTMLElement>("[data-glm-fit]").forEach((row) => {
+      row.style.display = f.glm52 ? "" : "none";
+    });
+    $("st-f-weights-label").textContent = f.glm52 ? "resident weights" : "weights";
+    $("st-f-transient-label").textContent = f.glm52 ? "other reserves" : "transient";
+    $("st-f-artifact").textContent = f.glm52?.artifact_disk_bytes
+      ? gb(f.glm52.artifact_disk_bytes) : "registry unavailable";
+    $("st-f-main-slab").textContent = gb(f.glm52?.main_expert_slab_bytes);
+    $("st-f-mtp-slab").textContent = gb(f.glm52?.mtp_expert_slab_bytes);
     $("st-f-weights").textContent = gb(r.weights_bytes);
     $("st-f-kv").textContent = gb(r.kv_bytes);
     $("st-f-transient").textContent = gb(r.transient_bytes);
@@ -221,7 +269,7 @@ export function createStatusController() {
         '</td><td class="num">' + row.ram_gb + " GB</td>" +
         '<td class="' + (row.fits ? "fit-yes" : "fit-no") + '">' + (row.fits ? "fits" : "no") + "</td>" +
         '<td class="' + dimCls + '">' + (row.max_context > 0 ? num(row.max_context) : "0 — weights alone don’t fit") + "</td>" +
-        '<td class="' + dimCls + '">' + (row.decode_tps > 0 ? "~" + row.decode_tps.toFixed(0) + " tok/s" : "—") + "</td></tr>";
+        '<td class="' + dimCls + '">' + (row.decode_tps > 0 ? "~" + tps(row.decode_tps) + " tok/s" : "—") + "</td></tr>";
     }).join("");
   }
 

package/src/web-tools.ts

@@ -21,6 +21,11 @@
 
 import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import {
+  fetchRestrictedHttpBytes,
+  type MediaFetchPolicy,
+  type RestrictedFetchDependencies,
+} from "./media-fetch";
 
 /** Tool names, exported so pi-web can add them to its tool allowlist. */
 export const WEB_TOOL_NAMES = ["web_search", "web_fetch", "weather"] as const;
@@ -31,6 +36,7 @@ const USER_AGENT =
   "(KHTML, like Gecko) Chrome/124.0 Safari/537.36";
 
 const FETCH_TIMEOUT_MS = 20_000;
+const MAX_FETCH_BYTES = 1024 * 1024;
 /** Cap on text returned to the model from a fetched page. */
 const MAX_FETCH_CHARS = 12_000;
 const DEFAULT_SEARCH_RESULTS = 5;
@@ -44,7 +50,7 @@ function withTimeout(signal: AbortSignal | undefined, ms: number): AbortSignal {
   return signal ? AbortSignal.any([signal, timeout]) : timeout;
 }
 
-interface FetchResult {
+export interface FetchResult {
   ok: boolean;
   status: number;
   finalUrl: string;
@@ -52,6 +58,20 @@ interface FetchResult {
   text: string;
 }
 
+export interface WebFetchOptions {
+  policy?: MediaFetchPolicy;
+  dependencies?: Partial<RestrictedFetchDependencies>;
+}
+
+const WEB_FETCH_POLICY: MediaFetchPolicy = {
+  allowPrivate: false,
+  privateDestinationHint:
+    "private/loopback destinations are never available to the model-driven web_fetch tool",
+  timeoutMs: FETCH_TIMEOUT_MS,
+  maxBytes: MAX_FETCH_BYTES,
+  maxRedirects: 5,
+};
+
 /** GET/POST a URL and read the body as text, with timeout + abort wiring. */
 async function httpText(
   url: string,
@@ -69,6 +89,38 @@ async function httpText(
   return { ok: res.ok, status: res.status, finalUrl: res.url || url, contentType, text };
 }
 
+/**
+ * Fetch a model-selected URL through the shared restricted-destination
+ * transport. Exported with dependency injection for deterministic,
+ * model-free security tests.
+ */
+export async function fetchWebText(
+  url: string,
+  signal?: AbortSignal,
+  options: WebFetchOptions = {},
+): Promise<FetchResult> {
+  const result = await fetchRestrictedHttpBytes(
+    url,
+    "web",
+    options.policy ?? WEB_FETCH_POLICY,
+    {
+      signal,
+      dependencies: options.dependencies,
+      headers: {
+        "user-agent": USER_AGENT,
+        accept: "text/html,application/json,text/plain,*/*",
+      },
+    },
+  );
+  return {
+    ok: result.ok,
+    status: result.status,
+    finalUrl: result.finalUrl,
+    contentType: result.contentType,
+    text: new TextDecoder().decode(result.bytes),
+  };
+}
+
 /** Normalize anything thrown by fetch (timeout, DNS, abort) into a message. */
 function describeFetchError(err: unknown): string {
   if (err instanceof Error) {
@@ -362,7 +414,7 @@ const webFetchTool = defineTool({
     let url = params.url.trim();
     if (!/^https?:\/\//i.test(url)) url = "https://" + url;
     try {
-      const res = await httpText(url, { headers: { accept: "text/html,application/json,text/plain,*/*" }, signal });
+      const res = await fetchWebText(url, signal);
       const header = `Fetched ${res.finalUrl} (HTTP ${res.status})`;
       if (!res.ok) return textResult(`${header}\n\n${truncate(htmlToText(res.text), 2_000)}`);
       const isHtml = /text\/html|application\/xhtml/i.test(res.contentType);