npm - openzoo - Versions diffs - 0.49.1 → 0.49.2 - Mend

openzoo 0.49.1 → 0.49.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/lib/grokui.mjs CHANGED Viewed

@@ -2569,6 +2569,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       return (await brainRace(callMsgs, emit, t.contextId, models, need, undefined, emitStatus, {
         signal: turnAbort.signal,
         onArrivals: (arr) => { t.lastRaceFail = summarizeRaceFailures(arr); },
+        tier: t.tier || 'medium',
       })).trim();
     }
     // A retry draws a DIFFERENT model from the tier rather than the same one.
@@ -4952,9 +4953,14 @@ const APP_HTML = `<!doctype html>
       const cogs = Number(you.cogsUsd) || 0;
       const direct = Number(you.directUsd) || 0;
       const margin = spent > 0 ? Math.round((spent - cogs) / spent * 100) + '%' : '—';
+      const cogsOver = cogs > spent;
       document.getElementById('hYouSpent').textContent = usd(spent);
-      document.getElementById('hYouCogs').textContent = usd(cogs);
-      document.getElementById('hYouMargin').textContent = margin;
+      const cogsEl = document.getElementById('hYouCogs');
+      cogsEl.textContent = usd(cogs);
+      cogsEl.className = cogsOver ? 'hember' : '';
+      const marginEl = document.getElementById('hYouMargin');
+      marginEl.textContent = margin;
+      marginEl.className = cogsOver ? 'hember' : 'hlime';
       document.getElementById('hYouDirect').textContent = usd(direct);
       const savedEl = document.getElementById('hYouSaved');
       const hintEl = document.getElementById('hHint');
@@ -4967,19 +4973,26 @@ const APP_HTML = `<!doctype html>
         // is shipping the WHOLE corpus), so 2dp would read as noise up there.
         savedEl.textContent = (mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x';
         savedEl.className = mult >= 1 ? 'hlime' : 'hember';
-        // Under 1x is real, but on its own it just reads as "this is a bad
-        // deal". It isn't a verdict on the product — it's a verdict on how
-        // little you've given it to work against: you're billed on the tokens
-        // actually forwarded, while "direct" is the cost of shipping the whole
-        // corpus. The forwarded slice grows barely at all as the corpus grows,
-        // so the ratio climbs with corpus size. Say that, and say what to do.
-        hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
-        hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
-          + 'not the corpus — so the more you bind, the further ahead this gets. '
-          + 'small inputs cost more than sending them straight.';
+        // Session direct/spent (never first-call). Cogs-over-paid is the
+        // louder warn — unused grant-back should have kept used cogs ≤ billed.
+        if (cogsOver) {
+          hintEl.className = 'hhint show';
+          hintEl.innerHTML = '<b>cogs above paid.</b> our cost exceeded what you were billed '
+            + '— this line is used racers, not the N+judge ceiling.';
+        } else {
+          hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
+          hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
+            + 'not the corpus — so the more you bind, the further ahead this gets. '
+            + 'small inputs cost more than sending them straight.';
+        }
       } else {
         savedEl.textContent = '—';
-        hintEl.className = 'hhint';
+        if (cogsOver) {
+          hintEl.className = 'hhint show';
+          hintEl.innerHTML = '<b>cogs above paid.</b> our cost exceeded what you were billed.';
+        } else {
+          hintEl.className = 'hhint';
+        }
       }
       document.getElementById('hFoot').textContent = (you.paidCalls || 0) + ' paid calls this session';
     } catch (e) {

package/lib/podagent.mjs CHANGED Viewed

@@ -28,12 +28,19 @@ import {
   isRaceCountable, raceLastShip, shouldRetryRaceArrival, raceFailKind,
   summarizeRaceFailures,
 } from './livestatus.js';
+import {
+  probeGatewayRace, capRaceByCredit, inferRaceTier, RACE_NO_CREDIT,
+} from './racesettle.js';
 import { homedir } from 'node:os';
 const PORTS = (process.env.OZ_AGENT_PORTS || '1337,6080,1340,6081')
   .split(',').map((s) => Number(s.trim())).filter(Boolean);
 const LOG = process.env.OZ_AGENT_LOG || '/var/log/openzoo/agent.jsonl';
 export const PROXY = process.env.OZ_PROXY || 'http://127.0.0.1:8402/v1';
+/** Live value — tests point OZ_PROXY at a mock after this module loads. */
+function completionsProxy() {
+  return process.env.OZ_PROXY || PROXY;
+}
 export const MODEL = process.env.OZ_BRAIN_MODEL || 'deepseek/deepseek-v4-pro-0813';
 const MAX_STEPS = Number(process.env.OZ_MAX_STEPS || 10);
@@ -289,7 +296,7 @@ async function postChat(body, contextId, topK, onStatus, signal) {
       err.name = 'AbortError';
       throw err;
     }
-    r = await fetch(`${PROXY}/chat/completions`, {
+    r = await fetch(`${completionsProxy()}/chat/completions`, {
       method: 'POST',
       headers: {
         'content-type': 'application/json', authorization: 'Bearer sk-openzoo',
@@ -649,6 +656,250 @@ export async function tierModels(tier, n = 1, random = false) {
   return a.slice(0, take);
 }
+async function readProxySession(proxy = completionsProxy()) {
+  try {
+    const origin = String(proxy || '').replace(/\/+$/, '').replace(/\/v1$/i, '');
+    const r = await fetch(`${origin}/v1/session`, { signal: AbortSignal.timeout(800) });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch { return null; }
+}
+async function raceBudget(hooks) {
+  if (hooks.creditUsd != null || hooks.quoteUsd != null) {
+    return { creditUsd: hooks.creditUsd, quoteUsd: hooks.quoteUsd };
+  }
+  // Injected stream = unit-test N-parallel path. Do not poke :8402.
+  if (hooks.stream) return {};
+  const s = await readProxySession(hooks.proxy || completionsProxy());
+  return {
+    creditUsd: s?.creditUsd,
+    quoteUsd: s?.lastQuoteUsd ?? s?.quoteUsd,
+  };
+}
+function raceRacerId(obj, fallback) {
+  const r = obj?.race || obj?.racer || {};
+  if (r.model) return String(r.model);
+  if (r.i != null) return `racer-${r.i}`;
+  if (obj?.model) return String(obj.model);
+  const idx = obj?.choices?.[0]?.index;
+  if (idx != null && idx !== 0) return `racer-${idx}`;
+  return fallback || 'gateway';
+}
+function raceEventOf(obj) {
+  const r = obj?.race || obj?.racer;
+  if (!r || typeof r !== 'object') return null;
+  const ev = String(r.event || r.status || '').toLowerCase();
+  return { id: raceRacerId(obj, 'gateway'), ev, text: r.text, error: r.error };
+}
+/**
+ * One Fly (or race-capable mock) POST. Streams tokens. First-X-countable:
+ * empties / HTTP / pay / fetch-failed do not fill X.
+ */
+async function brainGatewayRace(messages, onDelta, contextId, models, need, maxTokens, onStatus, hooks) {
+  const n = models.length;
+  const want = Math.max(1, Math.min(Number(need) || 1, n));
+  const tier = hooks.tier || inferRaceTier(models, 'medium');
+  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 arrivals = [];
+  const done = [];
+  const noteRace = (arr) => {
+    try {
+      hooks.onArrivals?.(arr);
+      const line = JSON.stringify({
+        at: new Date().toISOString(),
+        fail: summarizeRaceFailures(arr),
+        n: arr.length,
+        kinds: arr.map((a) => raceFailKind(a)),
+        door: 'gateway',
+      });
+      appendFileSync(`${homedir()}/.openzoo/grokui-race.log`, line + '\n');
+    } catch { /* diagnostic only */ }
+  };
+  const ship = (cand) => {
+    const out = cand && String(cand.text || '').trim() ? cand : raceLastShip(arrivals);
+    feed.settle(out);
+    noteRace(arrivals);
+    return out.text;
+  };
+  const vision = hasImages(messages);
+  const model = vision ? VISION_MODEL : (models[0] || MODEL);
+  const msgs = vision ? messages : stripImages(messages);
+  const budget = maxTokens || MAX_TOKENS;
+  const body = {
+    model,
+    max_tokens: budget,
+    messages: withModelId(msgs, model),
+    plugins: [{ id: 'web' }],
+    stream: true,
+    race: n,
+    race_need: want,
+    tier,
+  };
+  let lastFail = { model: 'gateway', text: '', error: 'empty body' };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const r = await postChat(body, contextId, 0, onStatus, hooks.signal);
+      if (!r.ok || !r.body) {
+        const j = await r.json().catch(() => ({}));
+        const content = j?.choices?.[0]?.message?.content;
+        const proxied = j?.error?.message;
+        const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
+        lastFail = { model: 'gateway', text: text || '', error: r.ok ? undefined : `HTTP ${r.status}` };
+        if (isRaceCountable(lastFail)) {
+          arrivals.push(lastFail);
+          done.push(lastFail);
+          feed.onBack();
+          if (text) onDelta(text);
+          break;
+        }
+        if (!shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+        continue;
+      }
+      const parsed = await readGatewayRaceStream(r, feed, hooks.signal);
+      for (const a of parsed.arrivals) {
+        arrivals.push(a);
+        if (isRaceCountable(a)) {
+          done.push(a);
+          feed.onBack();
+        } else {
+          feed.onFail(a.model);
+        }
+      }
+      lastFail = parsed.arrivals[parsed.arrivals.length - 1] || lastFail;
+      if (done.length >= want || !shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+    } catch (e) {
+      lastFail = { model: 'gateway', text: '', error: e?.message || 'error' };
+      arrivals.push(lastFail);
+      if (!shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+    }
+  }
+  const cands = done.slice(0, want);
+  if (!cands.length) return ship(raceLastShip(arrivals));
+  if (cands.length === 1) return ship(cands[0]);
+  onStatus?.('judging…');
+  const scored = await Promise.all(cands.map(async (c) => {
+    let score = 0;
+    try { score = Number(await classify(messages, c)) || 0; } catch { score = 0; }
+    return { ...c, score };
+  }));
+  let picked = pickRaceWinner(scored, minScore);
+  if (picked.reason === 'tie' && picked.tied.length > 1) {
+    let broken = null;
+    try { broken = await pairwise(messages, picked.tied); } catch { /* last of the tie */ }
+    const usable = broken && String(broken.text || '').trim();
+    picked = { winner: usable ? broken : picked.tied[picked.tied.length - 1], reason: 'tiebreak', tied: picked.tied };
+  }
+  return ship(picked.winner || scored[scored.length - 1] || raceLastShip(arrivals));
+}
+async function readGatewayRaceStream(r, feed, signal) {
+  const reader = r.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  const texts = new Map();
+  const finished = new Map();
+  const live = { id: null };
+  const stopWait = startModelWait(() => {});
+  const pushText = (id, chunk) => {
+    if (chunk == null || chunk === '') return;
+    const key = id || live.id || 'gateway';
+    live.id = key;
+    texts.set(key, (texts.get(key) || '') + chunk);
+    feed.onToken(key, chunk);
+  };
+  const finishOne = (id, extra = {}) => {
+    const key = id || live.id || 'gateway';
+    if (finished.has(key)) return;
+    const text = extra.text != null ? String(extra.text) : (texts.get(key) || '');
+    const row = { model: extra.model || key, text, error: extra.error };
+    finished.set(key, row);
+  };
+  try {
+    for (;;) {
+      if (signal?.aborted) break;
+      let chunk;
+      try {
+        chunk = await readWithIdleTimeout(reader, STREAM_IDLE_MS);
+      } catch (e) {
+        if (e?.code !== 'STREAM_IDLE') throw e;
+        try { await reader.cancel(); } catch { /* already */ }
+        break;
+      }
+      const { value, done } = chunk;
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        const s = line.trim();
+        if (s.startsWith(': race ')) {
+          try {
+            const ev = JSON.parse(s.slice(7));
+            const id = raceRacerId(ev, 'gateway');
+            if (ev.text && ev.event !== 'fail') pushText(id, ev.text);
+            if (ev.event === 'token' && ev.delta) pushText(id, ev.delta);
+            if (ev.event === 'back' || ev.event === 'done' || ev.finish) {
+              finishOne(id, { text: ev.text, model: ev.model });
+            }
+            if (ev.event === 'fail' || ev.error) {
+              finishOne(id, { text: ev.text || '', error: ev.error || 'empty body', model: ev.model });
+            }
+          } catch { /* keep-alive */ }
+          continue;
+        }
+        if (s.startsWith(': x402 ')) continue; // metered by the sidecar; never log
+        if (!s.startsWith('data:')) continue;
+        const payload = s.slice(5).trim();
+        if (payload === '[DONE]') continue;
+        try {
+          const obj = JSON.parse(payload);
+          const ev = raceEventOf(obj);
+          const c = obj?.choices?.[0];
+          const d = c?.delta;
+          const id = raceRacerId(obj, live.id || 'gateway');
+          if (d?.content) pushText(id, d.content);
+          else if (d?.reasoning || d?.reasoning_content) { /* thinking — not content */ }
+          if (c?.finish_reason) finishOne(id, { model: obj.model });
+          if (ev?.ev === 'back' || ev?.ev === 'done') finishOne(ev.id, { text: ev.text, model: ev.id });
+          if (ev?.ev === 'fail' || ev?.error) finishOne(ev.id, { text: ev.text || '', error: ev.error || 'empty body' });
+          const msg = c?.message?.content || obj?.choices?.[0]?.message?.content;
+          if (msg && (c?.finish_reason || obj.object === 'chat.completion')) {
+            pushText(id, texts.has(id) ? '' : msg);
+            if (!texts.get(id)) texts.set(id, String(msg));
+            finishOne(id, { text: texts.get(id) || msg, model: obj.model || id });
+          }
+        } catch { /* partial JSON */ }
+      }
+    }
+  } finally {
+    stopWait();
+    try { await reader.cancel(); } catch { /* closed */ }
+  }
+  if (!finished.size && texts.size) {
+    for (const [id, text] of texts) finishOne(id, { text });
+  }
+  const arrivals = [...finished.values()];
+  if (!arrivals.length) arrivals.push({ model: 'gateway', text: '', error: 'empty body' });
+  return { arrivals };
+}
 /**
  * Launch N models at once, judge the FIRST K that come back.
  *
@@ -693,10 +944,33 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   const classify = hooks.classify || classifyRaceAnswer;
   const pairwise = hooks.pairwise || pairwiseTied;
   const minScore = hooks.minScore != null ? Number(hooks.minScore) : RACE_MIN_SCORE;
-  const list = (models || []).filter(Boolean).slice(0, RACE_MAX);
+  let list = (models || []).filter(Boolean).slice(0, RACE_MAX);
+  const budget = await raceBudget(hooks);
+  const capped = capRaceByCredit(list.length, budget);
+  if (capped.n < 1) {
+    onStatus?.('race refused — no credit');
+    return RACE_NO_CREDIT;
+  }
+  if (capped.n < list.length) {
+    list = list.slice(0, capped.n);
+    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));
+  // One Fly settle when the completions door honors `race:`. Custom stream
+  // hooks (unit tests of the N-parallel judge) keep the old path. Old
+  // sidecar / local mock that does not accept race: also stays N-parallel.
+  const customStream = Boolean(hooks.stream);
+  let gateway = hooks.gatewayRace;
+  if (gateway == null && !customStream) {
+    try { gateway = await probeGatewayRace(hooks.proxy || completionsProxy(), hooks.fetch || fetch); }
+    catch { gateway = false; }
+  }
+  if (gateway && !customStream) {
+    return brainGatewayRace(messages, onDelta, contextId, list, want, maxTokens, onStatus, hooks);
+  }
   const feed = createRaceFeed(onDelta, onStatus, want);
   feed.start();

package/lib/proxy.js CHANGED Viewed

@@ -26,6 +26,7 @@ import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
 import { subscriptionPublicView } from './subscription.js';
 import { priceHoldings } from './livestatus.js';
+import { receiptUsedCogs } from './racesettle.js';
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
@@ -781,6 +782,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     console.log(line);
   };
   let sessionSpent = restored.spentUsd;
+  let lastQuoteUsd = null;
   let sessionCogs = restored.cogsUsd;
   let sessionDirect = restored.directUsd;
   const rememberSpend = () => {
@@ -791,6 +793,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   }
   process.on('exit', rememberSpend);
   const MARKUP = 3; // confirmed constant, see .claude/wiki.md "Margin needs a like-for-like denominator"
+  const noteQuote = (x) => {
+    const billed = Number(x?.billedUsd);
+    if (!Number.isFinite(billed) || billed < 0) return;
+    const n = Number(x?.race || x?.race_n || 1);
+    lastQuoteUsd = n > 1 ? billed / n : billed;
+  };
   let tunnelSpent = 0;
   // Live balance refresh state — the real implementation is assigned in the
   // banner section below; the handler only ever calls scheduleRefresh().
@@ -894,7 +902,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({
         spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls,
-        creditUsd, chainUsd: money.chainUsd,
+        creditUsd, chainUsd: money.chainUsd, lastQuoteUsd,
         subscription: subscriptionPublicView(),
       }));
       return;
@@ -1519,9 +1527,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           // is only correct on a straight-markup call: under counterfactual
           // pricing billedUsd is min(direct×discount, markupUsd), so the
           // division understates cost and overstates margin.
-          sessionCogs += typeof receipt.cogsUsd === 'number'
-            ? receipt.cogsUsd
-            : receipt.billedUsd / MARKUP;
+          sessionCogs += receiptUsedCogs(receipt, MARKUP);
+          noteQuote(receipt);
           // direct = what answering this WITHOUT the zoo would have cost. On an
           // attach call that is the whole bound corpus, which is why it can be
           // orders of magnitude above what was billed. directUsd is exact and
@@ -1591,7 +1598,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (!paid && data?.x402 && typeof data.x402.billedUsd === 'number') {
           const x = data.x402;
           sessionSpent += x.billedUsd;
-          sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+          sessionCogs += receiptUsedCogs(x, MARKUP);
+          noteQuote(x);
           sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
           if (didSpill) {
             // THE number that settles why a spilled call did or did not save:
@@ -1656,7 +1664,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       const meterStreamed = (x) => {
         if (paid || typeof x?.billedUsd !== 'number') return;
         sessionSpent += x.billedUsd;
-        sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+        sessionCogs += receiptUsedCogs(x, MARKUP);
+        noteQuote(x);
         sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
         if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; billedWithActual += x.billedUsd || 0; }
         if (didSpill) {

package/lib/racesettle.js ADDED Viewed

@@ -0,0 +1,143 @@
+/**
+ * Fly gateway race: one POST { race, race_need, tier }, unused grant-back,
+ * and HUD cogs for the racers that actually ran — never the N+judge ceiling.
+ */
+export const FLY_GATEWAY_HOST = 'x402-tokens.fly.dev';
+export const RACE_NO_CREDIT = '(race: not enough prepaid credit — shrink N or top up, rather than fire on $0)';
+const FLY_RE = /x402-tokens\.fly\.dev/i;
+/** Completions door is the Fly gateway (sidecar → x402-tokens.fly.dev). */
+export function isFlyGatewayUpstream(upstream) {
+  return FLY_RE.test(String(upstream || ''));
+}
+/**
+ * Whether this completions door will honor `race:` on POST /chat/completions.
+ * Fly (and a test mock that advertises it) → true. Old sidecar / local mock → false.
+ */
+export function doorAcceptsRace(info) {
+  if (!info || typeof info !== 'object') return false;
+  if (info.race === true || info.gatewayRace === true) return true;
+  if (info.race === false || info.gatewayRace === false) return false;
+  const features = info.features || info.caps || info.capabilities;
+  if (Array.isArray(features) && features.some((f) => String(f).toLowerCase() === 'race')) return true;
+  if (features && typeof features === 'object' && (features.race === true || features.gatewayRace === true)) {
+    return true;
+  }
+  return isFlyGatewayUpstream(info.upstream || info.apiBase || info.gateway);
+}
+let probeCache = { at: 0, ok: null, proxy: '' };
+export function resetGatewayRaceProbe() {
+  probeCache = { at: 0, ok: null, proxy: '' };
+}
+function proxyOrigin(proxy) {
+  const raw = String(proxy || '').replace(/\/+$/, '');
+  return raw.replace(/\/v1$/i, '');
+}
+/**
+ * Probe the sidecar / mock once. GET /v1/info (and /info) — never a paid
+ * completions call. Cached briefly so a race of 4 does not fan out probes.
+ */
+export async function probeGatewayRace(proxy, fetchFn = fetch, ttlMs = 60_000) {
+  const key = String(proxy || '');
+  if (probeCache.ok != null && probeCache.proxy === key && Date.now() - probeCache.at < ttlMs) {
+    return probeCache.ok;
+  }
+  const origin = proxyOrigin(key);
+  if (!origin) {
+    probeCache = { at: Date.now(), ok: false, proxy: key };
+    return false;
+  }
+  const paths = ['/v1/info', '/info'];
+  for (const p of paths) {
+    try {
+      const r = await fetchFn(`${origin}${p}`, { signal: AbortSignal.timeout(1500) });
+      if (!r.ok) continue;
+      const j = await r.json().catch(() => null);
+      const ok = doorAcceptsRace(j);
+      probeCache = { at: Date.now(), ok, proxy: key };
+      return ok;
+    } catch { /* try next */ }
+  }
+  probeCache = { at: Date.now(), ok: false, proxy: key };
+  return false;
+}
+/**
+ * If prepaid credit is known and `n × quote > credit`, shrink n (or 0 = refuse)
+ * rather than fire 4 groks on $0 credit. Unknown credit/quote → leave n alone.
+ */
+export function capRaceByCredit(n, { creditUsd, quoteUsd } = {}) {
+  const want = Math.max(0, Math.floor(Number(n) || 0));
+  if (creditUsd == null || !Number.isFinite(Number(creditUsd))) {
+    return { n: want, reason: null };
+  }
+  const credit = Number(creditUsd);
+  if (credit <= 0) return { n: 0, reason: 'no-credit' };
+  const quote = Number(quoteUsd);
+  if (!Number.isFinite(quote) || quote <= 0) {
+    // Credit is known and positive but we have no per-entrant quote — do not
+    // invent one. A $0 balance already refused above.
+    return { n: want, reason: null };
+  }
+  if (want * quote <= credit) return { n: want, reason: null };
+  const maxN = Math.floor(credit / quote);
+  if (maxN < 1) return { n: 0, reason: 'no-credit' };
+  return { n: Math.min(want, maxN), reason: 'shrunk' };
+}
+function unusedGrant(x) {
+  const u = x?.race_unused ?? x?.raceUnused ?? x?.unused;
+  if (u == null) return { billed: 0, cogs: 0 };
+  if (typeof u === 'number' && Number.isFinite(u)) return { billed: u, cogs: u };
+  if (typeof u !== 'object') return { billed: 0, cogs: 0 };
+  const billed = Number(u.billedUsd ?? u.refundUsd ?? u.unusedBilledUsd ?? u.usd ?? 0);
+  const cogs = Number(u.cogsUsd ?? u.unusedCogsUsd ?? u.refundCogsUsd ?? billed);
+  return {
+    billed: Number.isFinite(billed) && billed > 0 ? billed : 0,
+    cogs: Number.isFinite(cogs) && cogs > 0 ? cogs : 0,
+  };
+}
+/**
+ * Actual used-racer cogs after unused grant-back.
+ * Never the N+judge ceiling. Does not clamp to billed — HUD embers when
+ * used cogs still exceed what was paid.
+ */
+export function receiptUsedCogs(x, markup = 3) {
+  if (!x || typeof x !== 'object') return 0;
+  const billedRaw = Number(x.billedUsd);
+  const billedOk = Number.isFinite(billedRaw) && billedRaw >= 0;
+  let cogs = typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)
+    ? x.cogsUsd
+    : (billedOk ? billedRaw / markup : 0);
+  const grant = unusedGrant(x);
+  if (grant.cogs > 0) cogs = Math.max(0, cogs - grant.cogs);
+  return cogs;
+}
+/**
+ * Session meter. spent/direct are the receipt totals (already net of unused
+ * when the gateway refunds into billedUsd) — never a first-call rewrite.
+ * cogs is used racers after unused grant-back.
+ */
+export function meterRaceReceipt(x, markup = 3) {
+  const billed = Number(x?.billedUsd);
+  const spentUsd = Number.isFinite(billed) ? billed : 0;
+  const usedCogs = receiptUsedCogs(x, markup);
+  const direct = typeof x?.directUsd === 'number' ? x.directUsd : spentUsd;
+  return { spentUsd, cogsUsd: usedCogs, directUsd: direct };
+}
+export function inferRaceTier(models, fallback = 'medium') {
+  const list = Array.isArray(models) ? models : [];
+  const grok = list.filter((m) => /^x-ai\/grok/i.test(String(m)));
+  if (list.length && grok.length === list.length) return 'grok4.6';
+  return fallback;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.49.1",
+  "version": "0.49.2",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",