openzoo 0.49.4 → 0.49.6

package/lib/gui.html

@@ -194,7 +194,10 @@ async function send() {
     const x = d.x402 || {};
     state.calls += 1;
     if (typeof x.billedUsd === "number") state.spent += x.billedUsd;
-    if (typeof x.savesVsDirect === "number" && x.savesVsDirect > 0) state.saved += x.savesVsDirect;
+    if (typeof x.savedUsd === "number" && x.savedUsd > 0) state.saved += x.savedUsd;
+    else if (typeof x.directUsd === "number" && typeof x.billedUsd === "number") {
+      state.saved += Math.max(0, x.directUsd - x.billedUsd);
+    }
     const bits = [];
     if (typeof x.billedUsd === "number") bits.push(`$${x.billedUsd.toFixed(4)}`);
     if (x.lecore?.engaged) bits.push(`🧠 ${x.lecore.recalled ?? "?"} slices`);

package/lib/livestatus.js

@@ -28,6 +28,68 @@ export function formatPayStatus(attempt = 0) {
   return Number(attempt) > 0 ? 'waiting on x402…' : 'paying…';
 }
 
+/** Cut from 1-model savings. X does not change it — they pay every launched racer. */
+export function raceSavingsCutPct(y) {
+  const n = Math.max(1, Number(y) || 1);
+  return Math.round((1 - 1 / n) * 100);
+}
+
+function sitrepUsd(n) {
+  const x = Number(n) || 0;
+  return x >= 0.01 || x === 0 ? `$${x.toFixed(2)}` : `$${x.toFixed(5)}`;
+}
+
+function sitrepFlight({ status, liveStatus, liveRace } = {}) {
+  if (status !== 'thinking') return 'idle';
+  if (liveRace?.phase === 'judging') return 'classifier judging';
+  if (liveRace?.phase === 'winner') return 'winner';
+  if (liveStatus) return String(liveStatus);
+  return 'in flight';
+}
+
+/**
+ * Compact sitrep field list (drawer). No keys, no .npmrc.
+ * Prepaid is yes/no — never a secret.
+ */
+export function formatSitrep(info = {}) {
+  const y = Number(info.race) >= 2 ? Number(info.race) : 1;
+  const need = Number(info.raceNeed) || 1;
+  const spent = Number(info.spentUsd) || 0;
+  const cogs = Number(info.cogsUsd) || 0;
+  const direct = Number(info.directUsd) || 0;
+  const mult = spent > 0 ? direct / spent : null;
+  const saved = mult == null
+    ? '—'
+    : `${mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)}x`;
+  const credit = Number(info.creditUsd);
+  const prepaid = Number.isFinite(credit) && credit > 0 ? 'yes' : 'no';
+  return [
+    'Sitrep',
+    `  race        ${raceChoiceLabel(y, need)}`,
+    `  band        ${info.tier || 'medium'}`,
+    `  mode        ${info.runMode || 'ask'}`,
+    `  cwd         ${info.dir || '—'}`,
+    `  in flight   ${sitrepFlight(info)}`,
+    `  paid        ${sitrepUsd(spent)}`,
+    `  cogs        ${sitrepUsd(cogs)}`,
+    `  direct      ${sitrepUsd(direct)}`,
+    `  saved       ${saved}`,
+    `  paid calls  ${Number(info.paidCalls) || 0}`,
+    `  prepaid     ${prepaid}`,
+  ].join('\n');
+}
+
+/** Picker / sitrep label: `best 2 of 4  −75%`, `1 model  0%`. */
+export function raceChoiceLabel(y, need = 1) {
+  const n = Math.max(1, Number(y) || 1);
+  const k = Math.max(1, Math.min(Number(need) || 1, n));
+  const cut = raceSavingsCutPct(n);
+  const cutTxt = cut === 0 ? '0%' : `−${cut}%`;
+  if (n < 2) return `1 model  ${cutTxt}`;
+  if (k > 1) return `best ${k} of ${n}  ${cutTxt}`;
+  return `race ${n}  ${cutTxt}`;
+}
+
 /** First-X-back race: how many of the K we asked for have actually landed. */
 export function formatRaceStatus(back, need) {
   const n = Math.max(1, Number(need) || 1);
@@ -35,6 +97,24 @@ export function formatRaceStatus(back, need) {
   return `racing ${b}/${n} back…`;
 }
 
+/** OpenRouter id → short cell label. `z-ai/glm-4.7` → `glm-4.7`. */
+export function shortModelName(id) {
+  const s = String(id || '').trim();
+  if (!s) return 'model';
+  const parts = s.split('/');
+  return parts[parts.length - 1] || s;
+}
+
+/** Compact spectator preview — opening lines, not the whole answer. */
+export function clipRacePreview(text, maxLines = 8, maxChars = 420) {
+  const s = String(text || '').replace(/\r/g, '');
+  if (!s) return '';
+  const lines = s.split('\n');
+  let out = lines.length > maxLines ? lines.slice(0, maxLines).join('\n') + '\n…' : s;
+  if (out.length > maxChars) out = `${out.slice(0, maxChars - 1)}…`;
+  return out;
+}
+
 /** Race-level failure when no countable answer exists. Never a single model name. */
 export const RACE_EVERY_FAILED = '(race: every model failed — no reply)';
 
@@ -154,20 +234,76 @@ export function pickRaceWinner(cands, minScore = RACE_MIN_SCORE) {
 /**
  * Live race bubble: stream the fastest still-alive entrant, swap once if the
  * winner is someone else. `onDelta(text, { replace, model })`.
+ *
+ * `onRace(snap)` is the spectator feed — one cell per launched model, with
+ * waiting/streaming/back/failed/abandoned plus a truncated preview. Not a
+ * second racer: `phase: 'judging'` is the classifier looking at the X that
+ * already made it back.
  */
-export function createRaceFeed(onDelta, onStatus, need) {
+export function createRaceFeed(onDelta, onStatus, need, onRace) {
   let live = null;
   let settled = false;
   let back = 0;
+  let phase = 'racing';
+  let winnerModel = '';
+  let recutNote = '';
   const buf = new Map();
   const dead = new Set();
+  const order = [];
+  const cells = new Map();
   const paintStatus = () => { onStatus?.(formatRaceStatus(back, need)); };
+  const ensure = (model) => {
+    const id = String(model || '').trim() || 'model';
+    if (cells.has(id)) return cells.get(id);
+    const row = { model: id, status: 'waiting', preview: '', fail: '' };
+    cells.set(id, row);
+    order.push(id);
+    return row;
+  };
+  const freezeStragglers = () => {
+    if (back < need) return;
+    for (const row of cells.values()) {
+      if (row.status === 'waiting' || row.status === 'streaming') row.status = 'abandoned';
+    }
+  };
+  const snapshot = () => ({
+    need,
+    launched: order.length,
+    back,
+    phase,
+    winner: winnerModel || '',
+    recut: recutNote || '',
+    racers: order.map((id) => {
+      const row = cells.get(id);
+      return {
+        model: id,
+        short: shortModelName(id),
+        status: row.status,
+        preview: row.status === 'failed' ? '' : clipRacePreview(row.preview),
+        fail: row.fail || '',
+      };
+    }),
+  });
+  const emitRace = () => { onRace?.(snapshot()); };
   return {
-    start() { paintStatus(); },
+    start(models, extra) {
+      if (Array.isArray(models)) {
+        for (const m of models) if (m) ensure(m);
+      }
+      if (extra && extra.recut) recutNote = String(extra.recut);
+      paintStatus();
+      emitRace();
+    },
+    snapshot,
     liveModel() { return live; },
     onToken(model, chunk) {
       if (settled || chunk == null || chunk === '') return;
+      const row = ensure(model);
+      if (row.status === 'abandoned' || row.status === 'failed' || row.status === 'back') return;
       buf.set(model, (buf.get(model) || '') + chunk);
+      row.preview = buf.get(model) || '';
+      if (row.status === 'waiting') row.status = 'streaming';
+      emitRace();
       if (!live) {
         live = model;
         onDelta?.(chunk, { model });
@@ -175,8 +311,15 @@ export function createRaceFeed(onDelta, onStatus, need) {
       }
       if (live === model) onDelta?.(chunk, { model });
     },
-    onFail(model) {
+    onFail(model, arrival) {
       dead.add(model);
+      const row = ensure(model);
+      if (row.status !== 'abandoned' && row.status !== 'back') {
+        row.status = 'failed';
+        row.fail = raceFailKind(arrival || { model, text: '', error: 'error' });
+        row.preview = '';
+        emitRace();
+      }
       if (settled || live !== model) return;
       const next = [...buf.entries()].find(([m, t]) => m !== model && t && !dead.has(m));
       if (next) {
@@ -186,18 +329,44 @@ export function createRaceFeed(onDelta, onStatus, need) {
         live = null;
       }
     },
-    onBack() {
+    onBack(model) {
       // Late countable stragglers after ship used to paint "racing 4/2 back…"
       // onto an already-idle thread (GET /threads/:id returns raw liveStatus).
       if (settled || back >= need) return;
       back += 1;
+      let row = model ? ensure(model) : null;
+      if (!row) {
+        row = [...cells.values()].find((r) => r.status === 'streaming' || r.status === 'waiting');
+      }
+      if (row && row.status !== 'abandoned' && row.status !== 'failed') {
+        row.status = 'back';
+        if (buf.has(row.model)) row.preview = buf.get(row.model);
+      }
+      freezeStragglers();
       paintStatus();
+      emitRace();
+    },
+    judge() {
+      if (settled) return;
+      phase = 'judging';
+      freezeStragglers();
+      emitRace();
     },
     settle(winner) {
       settled = true;
+      phase = 'winner';
       const text = String(winner?.text || '').trim()
         ? winner.text
         : RACE_EVERY_FAILED;
+      winnerModel = winner?.error ? '' : (winner?.model || '');
+      if (winnerModel) {
+        const row = ensure(winnerModel);
+        if (row.status !== 'failed') {
+          row.status = 'back';
+          if (winner?.text) row.preview = String(winner.text);
+        }
+      }
+      emitRace();
       // Live stream already showing this answer — keep going, do not re-dump.
       if (winner?.model && live === winner.model && !winner.error) return;
       live = winner?.model || live;

package/lib/mcp.js

@@ -80,7 +80,7 @@ export function buildMcpServer() {
       + '(client-usable ceiling ~128M tokens; keep one call under ~9.8M) is bound once and the model reads only '
       + 'a few thousand tokens of it. Re-asking against an already-bound corpus is near-free and much faster, so '
       + 'send the corpus once and ask many questions. Returns the answer plus a payment receipt '
-      + '(billedUsd, savesVsDirect, tokens actually read).',
+      + '(billedUsd, directUsd, savedUsd, tokens actually read).',
     inputSchema: {
       prompt: z.string().describe('The question or instruction.'),
       corpus: z.string().optional().describe('Optional big context body (document dump, logs, book...). Placed before the prompt.'),
@@ -128,6 +128,8 @@ export function buildMcpServer() {
         receipt: receipt ? {
           line: receipt.line,
           billedUsd: receipt.billedUsd,
+          directUsd: receipt.directUsd,
+          savedUsd: receipt.savedUsd,
           savesVsDirect: receipt.savesVsDirect,
           pricing: receipt.pricing,
           rail: receipt.rail,

package/lib/pay.js

@@ -413,6 +413,9 @@ export class PayClient {
       line: receiptLine(accept, settle),
       rail: railOf(accept),
       billedUsd: accept.extra?.billedUsd,
+      directUsd: accept.extra?.directUsd,
+      savedUsd: accept.extra?.savedUsd,
+      cogsUsd: accept.extra?.cogsUsd,
       savesVsDirect: accept.extra?.savesVsDirect,
       pricing: accept.extra?.pricing,
       symbol: accept.extra?.symbol,

package/lib/podagent.mjs

@@ -30,6 +30,7 @@ import {
 } from './livestatus.js';
 import {
   probeGatewayRace, capRaceByCredit, inferRaceTier, RACE_NO_CREDIT,
+  recutRaceByHud, sessionDollarX,
 } from './racesettle.js';
 import { homedir } from 'node:os';
 
@@ -679,8 +680,16 @@ async function readProxySession(proxy = completionsProxy()) {
 }
 
 async function raceBudget(hooks) {
-  if (hooks.creditUsd != null || hooks.quoteUsd != null) {
-    return { creditUsd: hooks.creditUsd, quoteUsd: hooks.quoteUsd };
+  const injected = hooks.creditUsd != null || hooks.quoteUsd != null
+    || hooks.spentUsd != null || hooks.directUsd != null || hooks.dollarX != null;
+  if (injected) {
+    return {
+      creditUsd: hooks.creditUsd,
+      quoteUsd: hooks.quoteUsd,
+      spentUsd: hooks.spentUsd,
+      directUsd: hooks.directUsd,
+      dollarX: hooks.dollarX,
+    };
   }
   // Injected stream = unit-test N-parallel path. Do not poke :8402.
   if (hooks.stream) return {};
@@ -688,6 +697,8 @@ async function raceBudget(hooks) {
   return {
     creditUsd: s?.creditUsd,
     quoteUsd: s?.lastQuoteUsd ?? s?.quoteUsd,
+    spentUsd: s?.spentUsd,
+    directUsd: s?.directUsd,
   };
 }
 
@@ -719,8 +730,8 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
   const classify = hooks.classify || classifyRaceAnswer;
   const pairwise = hooks.pairwise || pairwiseTied;
   const minScore = hooks.minScore != null ? Number(hooks.minScore) : RACE_MIN_SCORE;
-  const feed = createRaceFeed(onDelta, onStatus, want);
-  feed.start();
+  const feed = createRaceFeed(onDelta, onStatus, want, hooks.onRace);
+  feed.start(models, hooks.raceRecut ? { recut: hooks.raceRecut } : undefined);
 
   const arrivals = [];
   const done = [];
@@ -772,7 +783,7 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
         if (isRaceCountable(lastFail)) {
           arrivals.push(lastFail);
           done.push(lastFail);
-          feed.onBack();
+          feed.onBack(lastFail.model);
           if (text) onDelta(text);
           break;
         }
@@ -785,9 +796,9 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
         arrivals.push(a);
         if (isRaceCountable(a)) {
           done.push(a);
-          feed.onBack();
+          feed.onBack(a.model);
         } else {
-          feed.onFail(a.model);
+          feed.onFail(a.model, a);
         }
       }
       lastFail = parsed.arrivals[parsed.arrivals.length - 1] || lastFail;
@@ -804,6 +815,7 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
   if (cands.length === 1) return ship(cands[0]);
 
   onStatus?.('judging…');
+  feed.judge();
   const scored = await Promise.all(cands.map(async (c) => {
     let score = 0;
     try { score = Number(await classify(messages, c)) || 0; } catch { score = 0; }
@@ -960,6 +972,31 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   const minScore = hooks.minScore != null ? Number(hooks.minScore) : RACE_MIN_SCORE;
   let list = (models || []).filter(Boolean).slice(0, RACE_MAX);
   const budget = await raceBudget(hooks);
+  let tier = hooks.tier || inferRaceTier(list, 'medium');
+  let wantNeed = Math.max(1, Math.min(Number(need) || 1, list.length || 1));
+  const dollarX = sessionDollarX(budget);
+  const hud = recutRaceByHud({
+    y: list.length, need: wantNeed, dollarX, tier,
+  });
+  let raceRecut = '';
+  if (hud.recut) {
+    raceRecut = 'savings';
+    if (hud.tier !== tier && !hooks.stream) {
+      try {
+        const next = await tierModels(hud.tier, hud.y, true);
+        if (next.length) { list = next; tier = hud.tier; }
+        else list = list.slice(0, hud.y);
+      } catch { list = list.slice(0, hud.y); }
+    } else {
+      list = list.slice(0, hud.y);
+      tier = hud.tier;
+    }
+    wantNeed = Math.min(hud.need, list.length);
+    onStatus?.(hud.y < 2
+      ? 'race recut to 1 — savings'
+      : `race recut to ${hud.y} — savings`);
+  }
+  hooks = { ...hooks, tier, raceRecut };
   const capped = capRaceByCredit(list.length, budget);
   if (capped.n < 1) {
     onStatus?.('race refused — no credit');
@@ -970,7 +1007,7 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
     onStatus?.(capped.n < 2 ? 'race shrunk to 1 — credit' : `race shrunk to ${capped.n} — credit`);
   }
   if (list.length < 2) return stream(messages, onDelta, contextId, list[0], maxTokens, 0, 0, onStatus);
-  const want = Math.max(1, Math.min(Number(need) || 1, list.length));
+  const want = Math.max(1, Math.min(wantNeed, list.length));
 
   // One Fly settle when the completions door honors `race:`. Custom stream
   // hooks (unit tests of the N-parallel judge) keep the old path. Old
@@ -985,8 +1022,8 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
     return brainGatewayRace(messages, onDelta, contextId, list, want, maxTokens, onStatus, hooks);
   }
 
-  const feed = createRaceFeed(onDelta, onStatus, want);
-  feed.start();
+  const feed = createRaceFeed(onDelta, onStatus, want, hooks.onRace);
+  feed.start(list, raceRecut ? { recut: raceRecut } : undefined);
 
   const done = [];
   const arrivals = [];
@@ -1034,7 +1071,7 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
         if (isRaceCountable(last)) {
           arrivals.push(last);
           done.push(last);
-          feed.onBack();
+          feed.onBack(m);
           return;
         }
       } catch (e) {
@@ -1043,7 +1080,7 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
       if (!shouldRetryRaceArrival(last) || attempt === 1 || raceAbort.signal.aborted) break;
     }
     arrivals.push(last);
-    feed.onFail(m);
+    feed.onFail(m, last);
   };
 
   const attempts = list.map((m) => runOne(m).finally(() => {
@@ -1068,6 +1105,7 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   if (cands.length === 1) return ship(cands[0]);
 
   onStatus?.('judging…');
+  feed.judge();
   const scored = await Promise.all(cands.map(async (c) => {
     let score = 0;
     try { score = Number(await classify(messages, c)) || 0; } catch { score = 0; }