openzoo 0.49.4 → 0.49.6

package/lib/proxy.js

@@ -15,6 +15,8 @@ import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
   loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
   createSpillStats, corpusCharsForSend, applySpillCut, msgText, hudDollarX,
+  spillPricedLine,
+  planConversationBind, rememberSpillMemo, SPILL_CONTENT_ANCHOR_CHARS,
 } from './spill.js';
 import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -26,7 +28,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';
+import { receiptUsedCogs, receiptDirectUsd } from './racesettle.js';
 import { rewriteWrapClientError } from './wrap.js';
 
 const HOP_BY_HOP = new Set([
@@ -423,11 +425,6 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
     });
   };
 
-  if (msgs.length < 6) {
-    bindFilesInBackground('conversation under 6 messages, background');
-    return null;
-  }
-
   // LIVE SELF-TUNER. Env knobs seed the first cut; after cut+stub the proxy
   // scores the HUD dollar multiple (spill direct/billed) and retunes
   // keep/min-turns/budget (stubMore for SEARCH, not live file bodies)
@@ -488,35 +485,23 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   //
   // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
   //
-  // The FIRST bind of a session is necessarily synchronous � the request cannot
-  // go until the context_id exists, because it travels as x-hrr-context. Folding
-  // file bytes into that bind put a 400KB upload in front of the caller's turn,
-  // which is the cold-bind stall this whole exercise was meant to remove: the
-  // bind endpoint measures 0.34-0.48s on a 613KB corpus, and that is 0.34-0.48s
-  // the user waits before a single token appears.
+  // The first conversation bind is also fire-and-forget: turn 1 may go out
+  // unspilled while the bind runs, then later turns recall a tail + contextId.
+  // Folding file bytes into a synchronous first bind used to put a 400KB
+  // upload in front of the caller's turn (0.34-0.48s on a 613KB corpus).
   //
-  // Nothing recalls a file during the turn that read it � the model already has
+  // Nothing recalls a file during the turn that read it � the model already has
   // the tool result in its window. Files are only worth having bound for the
-  // NEXT ask. So the conversation binds inline and the files are appended after
-  // the fact, off the clock.
+  // NEXT ask, so they append after the conversation bind completes.
   const turns = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
   const corpus = turns;
-  if (!sessionKey) sessionKey = corpus.slice(0, 2048);
+  if (!sessionKey) sessionKey = corpus.slice(0, SPILL_CONTENT_ANCHOR_CHARS);
 
-  // FILES BIND EVEN WHEN THE CONVERSATION IS TOO SMALL TO SPILL.
-  //
-  // The threshold exists to stop us binding a two-line chat � it was never
-  // meant to gate FILES. But bailing here skipped them entirely, so a fresh
-  // session that reads a 200KB file bound nothing and scored 1.00x forever:
-  // OBSERVED on a live session that read files all turn and never produced a
-  // corpus, because its conversation stayed under the threshold the whole time.
-  //
-  // A file is worth binding on its own merit. So when the turns are too small
-  // to spill but files exist, bind the files anyway � in the background,
-  // against this session's context � and let this turn go unspilled. The corpus
-  // is then waiting for the next ask.
-  if (corpus.length <= BIND_MIN_CHARS) {
-    bindFilesInBackground('conversation under spill threshold, background');
+  // Conversation prefix binds at any size. BIND_MIN_CHARS only gates the
+  // one-shot corpus+question path in maybeCacheCorpus � a real but small
+  // early-turn prefix used to be discarded here ("only large ones").
+  if (!corpus) {
+    bindFilesInBackground('empty conversation prefix, files only');
     return null;
   }
 
@@ -524,7 +509,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   //
   // A transcript grows by one message per turn, so the whole-corpus hash misses
   // every time and the old code re-uploaded the ENTIRE prefix on every single
-  // turn — OBSERVED live: 0.4MB bound three turns running, a fresh context id
+  // turn � OBSERVED live: 0.4MB bound three turns running, a fresh context id
   // each time, while only a few KB was actually new. Bind cost grew with
   // conversation length and was re-paid per message.
   //
@@ -537,7 +522,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // The anchor was the first 2KB of corpus, which works only because a
   // transcript's opening never changes. It is fragile in exactly the cases that
   // matter: two sessions that open identically (same system block, same first
-  // instruction — the norm for an agent) collide onto ONE bound context and
+  // instruction � the norm for an agent) collide onto ONE bound context and
   // interleave their histories, and any edit near the top of a transcript
   // silently orphans the binding and re-uploads the whole thing.
   //
@@ -545,60 +530,109 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // back to the content anchor when it is not. Same memo, better key.
   // CAPTURED FROM A LIVE claude-cli/2.1.232 REQUEST, not guessed. The first
   // version of this checked x-session-id / x-claude-session-id /
-  // metadata.user_id — none of which Claude Code sends, so it silently fell
+  // metadata.user_id � none of which Claude Code sends, so it silently fell
   // back to the content anchor on every request and the feature did nothing.
   // The real header list is:
   //   anthropic-beta, anthropic-version, x-app, x-claude-code-session-id,
   //   x-stainless-*
-  const anchor = sessionKey;
-  const persisted = sessionKey ? sessionLedger.get(sessionKey) : null;
-  const prior = spillMemo.get(anchor) || (persisted?.contextId
-    ? { contextId: persisted.contextId, hash: persisted.hash || '', corpus: null, restored: true }
-    : null);
+  //
+  // COLD-BIND. Turn 1 may go unspilled (full messages, no x-hrr-context) while
+  // the first bind runs in the background � same spirit as file-bind, so the
+  // opening ask is not stalled. The in-flight/completed bind is memoized on
+  // the session key; later turns recall a tail + contextId. Subsequent
+  // appends stay fire-and-forget deltas.
+  let bindPlan = planConversationBind({
+    sessionKey,
+    corpus,
+    spillMemo,
+    sessionLedger,
+  });
+  const anchor = bindPlan.key || sessionKey;
+
+  if (bindPlan.action === 'cold-bind') {
+    const ready = bindCorpus(corpus, {
+      onStage: (stage, info) => {
+        if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of transcript to holographic memory (background)...`);
+      },
+    }).then((b) => {
+      if (!b?.contextId) return b;
+      noteCorpusLedger(boundChars, {
+        contextId: b.contextId,
+        reused: false,
+        corpusChars: corpus.length,
+        deltaChars: 0,
+        fileChars: 0,
+        ...ledgerOpts(),
+      });
+      rememberSpillMemo(spillMemo, anchor, { corpus, contextId: b.contextId, hash: b.hash });
+      bindFilesInBackground('background', { appendTo: b.contextId, asAppend: true });
+      return b;
+    }).catch((e) => {
+      log(`bind failed (turn went unspilled): ${e.message}`);
+      const cur = spillMemo.get(anchor);
+      if (cur?.pending) spillMemo.delete(anchor);
+      return null;
+    });
+    rememberSpillMemo(spillMemo, anchor, { corpus, pending: true, ready });
+    return null;
+  }
+
+  if (bindPlan.action === 'await-pending') {
+    const finished = await bindPlan.ready.catch((e) => {
+      log(`bind failed (history may lag one turn): ${e.message}`);
+      return null;
+    });
+    if (!finished?.contextId) {
+      bindFilesInBackground('first bind failed, files only');
+      return null;
+    }
+    bindPlan = planConversationBind({
+      sessionKey: anchor,
+      corpus,
+      spillMemo,
+      sessionLedger,
+    });
+  }
+
+  if (bindPlan.action !== 'recall' || !bindPlan.contextId) {
+    bindFilesInBackground('no context yet, files only');
+    return null;
+  }
+
   let bind;
   let deltaChars = 0;
   let appended = false;
-  if (prior?.restored && prior.contextId) {
+  if (bindPlan.restored && bindPlan.contextId) {
     // Sidecar came back up: we still know the context_id and the accumulated
     // char count, but not the prior prefix string, so we cannot slice a delta.
     // Re-append the current prefix (some overlap is harmless) and keep the
-    // restored ledger � do not add corpus.length again.
+    // restored ledger � do not add corpus.length again.
     void bindCorpus(corpus, {
-      appendTo: prior.contextId,
+      appendTo: bindPlan.contextId,
       onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${prior.contextId} (restored session, background)`);
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${bindPlan.contextId} (restored session, background)`);
       },
     }).catch((e) => log(`append failed (history may lag one turn): ${e.message}`));
     appended = true;
-    bind = { contextId: prior.contextId, hash: prior.hash, reused: true, bytes: 0 };
-  } else if (prior && typeof prior.corpus === 'string' && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
-    const delta = corpus.slice(prior.corpus.length);
+    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: 0 };
+  } else if (bindPlan.append && bindPlan.delta) {
+    const delta = bindPlan.delta;
     deltaChars = delta.length;
-    // FIRE AND FORGET. This delta is history for FUTURE turns � the answer
+    // FIRE AND FORGET. This delta is history for FUTURE turns � the answer
     // being generated right now is served from the tail plus what is already
     // bound, so waiting on the upload buys nothing and costs the user the
     // round trip on every single turn. The context id is already known, so
     // nothing is lost by not waiting for it.
-    //
-    // The FIRST bind is deliberately NOT async: the request must carry
-    // x-hrr-context, and that id does not exist until the bind returns. Firing
-    // that one off would send the opening turn with no context at all � a
-    // silently worse answer traded for a shorter pause, which is the wrong way
-    // round.
     void bindCorpus(delta, {
-      appendTo: prior.contextId,
+      appendTo: bindPlan.contextId,
       onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${prior.contextId} (delta, background)`);
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${bindPlan.contextId} (delta, background)`);
       },
     }).catch((e) => log(`append failed (history may lag one turn): ${e.message}`));
     appended = true;
-    bind = { contextId: prior.contextId, hash: prior.hash, reused: true, bytes: delta.length };
+    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: delta.length };
   } else {
-    bind = await bindCorpus(corpus, {
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of transcript to holographic memory...`);
-      },
-    });
+    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: 0 };
   }
   // CONVERSATION LEDGER � every successful bind AND append, not only when
   // files exist. First bind initializes to the bound corpus size; each append
@@ -618,8 +652,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // uploads each version exactly once no matter how often the agent re-reads it.
   // Read + readdir are inside setImmediate � they must not run before send().
   bindFilesInBackground('background', { appendTo: bind.contextId, asAppend: true });
-  spillMemo.set(anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
-  if (spillMemo.size > 32) spillMemo.delete(spillMemo.keys().next().value);
+  rememberSpillMemo(spillMemo, anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
   // Count the tail that is actually forwarded after stub/trim � older
   // continue-turn rounds after the ask may have been dropped, so
   // msgs.length - cut would keep lastSend growing with the raw pile.
@@ -793,7 +826,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     say(`session restored: $${sessionSpent.toFixed(6)} � ${paidCalls} paid call${paidCalls === 1 ? '' : 's'}`);
   }
   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;
@@ -1519,30 +1551,20 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       if (paid && receipt) {
         if (receipt.ok && typeof receipt.billedUsd === 'number') {
           sessionSpent += receipt.billedUsd;
-          // cogs: no per-call field for it, but MARKUP is a known constant
-          // (3x — confirmed against the gateway's own margin math), and
-          // billedUsd = cogs * markup on a straight-markup call. Close enough
-          // on a counterfactual (leCore-discounted) call too since markup is
-          // still the ceiling those get capped against.
-          // Prefer the gateway's own cogsUsd. Deriving it as billedUsd/MARKUP
-          // 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 += receiptUsedCogs(receipt, MARKUP);
+          // Wallet path: no 3x. Prefer extra.cogsUsd / billedUsd / directUsd /
+          // savedUsd from the 402. billedUsd is the OpenRouter price (plus
+          // zoo's 33% of savings when the caller beat direct).
+          sessionCogs += receiptUsedCogs(receipt);
           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
-          // always present; savesVsDirect is the same number as a ratio.
+          // orders of magnitude above what was billed. Read extra.directUsd /
+          // extra.savedUsd; do not invent billed * 3.
           if (didSpill) {
             spill.spillSpend += receipt.billedUsd || 0;
-            spill.spillDirect += typeof receipt.directUsd === 'number' ? receipt.directUsd : (receipt.billedUsd || 0);
+            spill.spillDirect += receiptDirectUsd(receipt);
           }
-          sessionDirect += typeof receipt.directUsd === 'number'
-            ? receipt.directUsd
-            : typeof receipt.savesVsDirect === 'number'
-              ? receipt.savesVsDirect * receipt.billedUsd
-              : receipt.billedUsd;
+          sessionDirect += receiptDirectUsd(receipt);
           // The public-URL ceiling meters only public-origin spend — your own
           // local calls never eat into it.
           if (viaTunnel) tunnelSpent += receipt.billedUsd;
@@ -1599,23 +1621,19 @@ 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 += receiptUsedCogs(x, MARKUP);
+          sessionCogs += receiptUsedCogs(x);
           noteQuote(x);
-          sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+          sessionDirect += receiptDirectUsd(x);
           if (didSpill) {
             // THE number that settles why a spilled call did or did not save:
             // the gateway only prices a counterfactual when corpusTokens >
             // promptTokens, so a tail that rivals the corpus silently falls
-            // back to markup and direct collapses onto billed.
-            const lc = x.lecore || {};
-            // counterfactualTokensUsed is the basis the gateway ACTUALLY priced
-            // on. lecore.corpusTokens is often absent and reading it printed
-            // 'corpus ?' on calls that were pricing fine — which sent a whole
-            // night's debugging after a number that was never the input.
-            const basis = x.counterfactualTokensUsed ?? lc.corpusTokens;
-            log(`spill priced: ${x.pricing} · basis ${basis ?? '?'} tok vs sent ${lc.tokensBefore ?? '?'} -> ${lc.tokensAfter ?? '?'} · billed ${(x.billedUsd ?? 0).toFixed(5)} direct ${(x.directUsd ?? 0).toFixed(5)}`);
+            // back to at-cost and direct collapses onto billed.
+            // Tell-line prints the gateway's actual counterfactual only.
+            // Never fall back to lecore.corpusTokens (often == tokensBefore).
+            log(spillPricedLine(x));
             spill.spillSpend += x.billedUsd;
-            spill.spillDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+            spill.spillDirect += receiptDirectUsd(x);
           }
           paidCalls += 1;
           if (viaTunnel) tunnelSpent += x.billedUsd;
@@ -1665,15 +1683,14 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       const meterStreamed = (x) => {
         if (paid || typeof x?.billedUsd !== 'number') return;
         sessionSpent += x.billedUsd;
-        sessionCogs += receiptUsedCogs(x, MARKUP);
+        sessionCogs += receiptUsedCogs(x);
         noteQuote(x);
-        sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+        sessionDirect += receiptDirectUsd(x);
         if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; billedWithActual += x.billedUsd || 0; }
         if (didSpill) {
-          const lc = x.lecore || {};
-          log(`spill priced (streamed): ${x.pricing} · basis ${x.counterfactualTokensUsed ?? '?'} tok vs sent ${lc.tokensBefore ?? '?'} -> ${lc.tokensAfter ?? '?'} · billed ${(x.billedUsd ?? 0).toFixed(5)} direct ${(x.directUsd ?? 0).toFixed(5)}`);
+          log(spillPricedLine(x, { streamed: true }));
           spill.spillSpend += x.billedUsd;
-          spill.spillDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+          spill.spillDirect += receiptDirectUsd(x);
         }
         paidCalls += 1;
         if (viaTunnel) tunnelSpent += x.billedUsd;

package/lib/racesettle.js

@@ -8,6 +8,62 @@
 
 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)';
+/** Low end of the pitched 5–10× vs frontier. Session green HUD below this recuts Y. */
+export const RACE_HUD_TARGET = 5;
+
+const TIER_DOWN = {
+  'grok4.6': 'medium',
+  grok46: 'medium',
+  expensive: 'medium',
+  medium: 'cheap',
+  cheap: 'cheap',
+};
+
+export function cheaperRaceTier(tier) {
+  const t = String(tier || 'medium');
+  return TIER_DOWN[t] || 'cheap';
+}
+
+/** Same number the HUD green `x` uses: direct/spent. */
+export function sessionDollarX({ dollarX, spentUsd, directUsd } = {}) {
+  const given = Number(dollarX);
+  if (Number.isFinite(given) && given > 0) return given;
+  const spent = Number(spentUsd);
+  const direct = Number(directUsd);
+  if (spent > 0 && Number.isFinite(direct)) return direct / spent;
+  return null;
+}
+
+/**
+ * Recut launched Y (and maybe drop a band) when session green HUD is thin.
+ * Assumes the current multiple already includes this Y tax, so implied
+ * single-model x ≈ dollarX × y. Need (X) scales with Y. No user refunds.
+ *
+ * 2.09x on a 4-racer → implied ~8.4x single → Y=1 (back in the 5–10× band).
+ */
+export function recutRaceByHud({
+  y, need = 1, dollarX, tier = 'medium', target = RACE_HUD_TARGET,
+} = {}) {
+  const launched = Math.max(1, Math.floor(Number(y) || 1));
+  const k = Math.max(1, Math.min(Math.floor(Number(need) || 1), launched));
+  const x = Number(dollarX);
+  const band = String(tier || 'medium');
+  if (!Number.isFinite(x) || x <= 0 || x >= target) {
+    return { y: launched, need: k, tier: band, recut: false, reason: null };
+  }
+  const impliedSingle = x * launched;
+  const maxY = Math.max(1, Math.min(launched, Math.floor(impliedSingle / target)));
+  const nextTier = impliedSingle < target ? cheaperRaceTier(band) : band;
+  const nextNeed = Math.max(1, Math.min(k, maxY));
+  const recut = maxY < launched || nextTier !== band;
+  return {
+    y: maxY,
+    need: nextNeed,
+    tier: nextTier,
+    recut,
+    reason: recut ? 'savings' : null,
+  };
+}
 
 const FLY_RE = /x402-tokens\.fly\.dev/i;
 
@@ -99,13 +155,29 @@ export function capRaceByCredit(n, { creditUsd, quoteUsd } = {}) {
  * House cost from the receipt. Do not subtract race_unused — unused
  * grant-back is not a user refund, and shrinking cogs would hide house loss.
  * Does not clamp to billed — HUD embers when cogs exceed what was paid.
+ *
+ * Wallet path: there is no 3× markup. Prefer the gateway's cogsUsd; otherwise
+ * billedUsd (OpenRouter price, plus zoo's 33% of savings when the 402 has any).
  */
-export function receiptUsedCogs(x, markup = 3) {
+export function receiptUsedCogs(x) {
   if (!x || typeof x !== 'object') return 0;
-  const billedRaw = Number(x.billedUsd);
-  const billedOk = Number.isFinite(billedRaw) && billedRaw >= 0;
   if (typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)) return x.cogsUsd;
-  return billedOk ? billedRaw / markup : 0;
+  const billedRaw = Number(x.billedUsd);
+  return Number.isFinite(billedRaw) && billedRaw >= 0 ? billedRaw : 0;
+}
+
+/** Counterfactual from the 402: extra.directUsd, else billed + savedUsd. */
+export function receiptDirectUsd(x) {
+  if (typeof x?.directUsd === 'number' && Number.isFinite(x.directUsd)) return x.directUsd;
+  const billed = Number(x?.billedUsd);
+  const billedOk = Number.isFinite(billed) && billed >= 0;
+  if (typeof x?.savedUsd === 'number' && Number.isFinite(x.savedUsd) && billedOk) {
+    return billed + x.savedUsd;
+  }
+  if (typeof x?.savesVsDirect === 'number' && Number.isFinite(x.savesVsDirect) && billedOk) {
+    return x.savesVsDirect * billed;
+  }
+  return billedOk ? billed : 0;
 }
 
 /**
@@ -113,12 +185,10 @@ export function receiptUsedCogs(x, markup = 3) {
  * first-call rewrite, never a race_unused user refund.
  * cogs is the house cost on that receipt (HUD embers when cogs > spent).
  */
-export function meterRaceReceipt(x, markup = 3) {
+export function meterRaceReceipt(x) {
   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 };
+  return { spentUsd, cogsUsd: receiptUsedCogs(x), directUsd: receiptDirectUsd(x) };
 }
 
 export function inferRaceTier(models, fallback = 'medium') {