openzoo 0.49.4 → 0.49.6

package/lib/spill.js

@@ -118,6 +118,31 @@ export function corpusCharsForSend(boundChars, contextId, thisTurn) {
   return Math.max(boundChars.get(contextId) || 0, thisTurn || 0);
 }
 
+/**
+ * Pricing / unspilled basis: the unspilled size, never the shrunken sent
+ * (tokensAfter) size. Same unit on both args — tokens or chars, not mixed.
+ */
+export function unspilledBasis({ tokensBefore, corpus } = {}) {
+  return Math.max(Number(tokensBefore) || 0, Number(corpus) || 0);
+}
+
+/**
+ * Gateway counterfactual the tell-line must print. Missing / non-finite /
+ * non-positive → null (`basis ?`). Never reads lecore.corpusTokens.
+ */
+export function spillPricedTellBasis(x) {
+  const n = Number(x?.counterfactualTokensUsed);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+/** Exact `spill priced:` / `spill priced (streamed):` line the proxy logs. */
+export function spillPricedLine(x, { streamed = false } = {}) {
+  const lc = x?.lecore || {};
+  const basis = spillPricedTellBasis(x);
+  const prefix = streamed ? 'spill priced (streamed):' : 'spill priced:';
+  return `${prefix} ${x?.pricing} · basis ${basis ?? '?'} tok vs sent ${lc.tokensBefore ?? '?'} -> ${lc.tokensAfter ?? '?'} · billed ${(x?.billedUsd ?? 0).toFixed(5)} direct ${(x?.directUsd ?? 0).toFixed(5)}`;
+}
+
 /** Expand ~ and resolve relative paths against cwd. Returns null if unusable. */
 export function resolveReadablePath(p, cwd = process.cwd()) {
   if (typeof p !== 'string') return null;
@@ -1256,9 +1281,9 @@ function lastUserAskIndex(msgs, firstSpillable) {
   return -1;
 }
 
-function countRealTurns(msgs, from) {
+function countRealTurns(msgs, from, to = msgs.length) {
   let n = 0;
-  for (let i = from; i < msgs.length; i++) {
+  for (let i = from; i < to; i++) {
     const r = msgs[i]?.role;
     if (r === 'user' || r === 'assistant') n += 1;
   }
@@ -1356,7 +1381,9 @@ export function trimUnseverablePairs(msgs, {
 
 /**
  * Pick a severable cut: keep a recent tail, honour the byte budget, floor
- * at minTurns of user/assistant, and never drop the last user ask.
+ * at minTurns of user/assistant on a LONG thread, and never drop the last
+ * user ask. minTurns must not empty the bind prefix — a short AUTO thread
+ * binds early turns and may forward a tail with fewer than minTurns.
  */
 export function cutTranscript(msgs, knobs = {}) {
   const k = sanitizeKnobs({ ...envKnobs(), ...knobs });
@@ -1398,21 +1425,38 @@ export function cutTranscript(msgs, knobs = {}) {
   }
   if (tailStart > cut) cut = tailStart;
 
+  const lastUser = lastUserAskIndex(msgs, firstSpillable);
+
+  // minTurns may still size the tail on a long thread. If walking earlier
+  // would empty the bind prefix (the old firstSpillable+1 fallback), keep a
+  // non-empty prefix and allow fewer than minTurns in the tail. On a short
+  // thread that cannot satisfy minTurns at all, pin the last ask so early
+  // user/assistant turns bind instead of riding in the forwarded tail.
   if (countRealTurns(msgs, cut) < minTurns) {
+    let moved = false;
     for (let i = cut - 1; i > firstSpillable; i--) {
-      if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= minTurns) { cut = i; break; }
-      if (i === firstSpillable + 1) { if (isSeverable(msgs, i, firstSpillable)) cut = i; break; }
+      if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= minTurns) {
+        cut = i;
+        moved = true;
+        break;
+      }
+    }
+    if (!moved && lastUser > firstSpillable && isSeverable(msgs, lastUser, firstSpillable)) {
+      cut = lastUser;
     }
   }
 
-  const lastUser = lastUserAskIndex(msgs, firstSpillable);
   if (lastUser > firstSpillable && cut > lastUser) cut = lastUser;
 
-  // Never shrink below 2 real turns when that would drop the ask — the ask
-  // always stays; expand earlier only if two turns exist and remain after it.
+  // 2-real-turn floor protects the last user ask: never drop it, and expand
+  // the tail to two turns on a LONG thread. Do not steal the first
+  // user+assistant pair from the prefix just to pad a short tail.
   if (lastUser > firstSpillable && countRealTurns(msgs, cut) < 2) {
     for (let i = cut - 1; i > firstSpillable; i--) {
-      if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= 2) { cut = i; break; }
+      if (!isSeverable(msgs, i, firstSpillable) || countRealTurns(msgs, i) < 2) continue;
+      if (countRealTurns(msgs, firstSpillable, i) < 2) continue;
+      cut = i;
+      break;
     }
     if (cut > lastUser) cut = lastUser;
   }
@@ -1420,6 +1464,121 @@ export function cutTranscript(msgs, knobs = {}) {
   return { cut, firstSpillable, lastUser, knobs: k };
 }
 
+/** Opening slice used as a content-anchor when no session header is sent. */
+export const SPILL_CONTENT_ANCHOR_CHARS = 2048;
+
+/**
+ * Find a memoized / ledger bind for this request. Prefers an explicit
+ * session key; otherwise matches a stored prefix so a growing content-anchor
+ * (grokui AUTO sends no session header) still recalls the same contextId.
+ */
+export function lookupSpillMemo(spillMemo, sessionLedger, { sessionKey, corpus } = {}) {
+  if (sessionKey && spillMemo?.has(sessionKey)) {
+    return { key: sessionKey, source: 'memo', ...spillMemo.get(sessionKey) };
+  }
+  if (sessionKey && sessionLedger?.has(sessionKey)) {
+    const led = sessionLedger.get(sessionKey);
+    if (led?.contextId) return { key: sessionKey, source: 'ledger', restored: !led.corpus, ...led };
+  }
+  if (corpus && spillMemo) {
+    for (const [k, v] of spillMemo) {
+      if (typeof v?.corpus === 'string' && v.corpus.length && corpus.startsWith(v.corpus)) {
+        return { key: k, source: 'memo-prefix', ...v };
+      }
+    }
+    const opening = corpus.slice(0, SPILL_CONTENT_ANCHOR_CHARS);
+    for (const [k, v] of spillMemo) {
+      if (typeof k !== 'string' || k.startsWith('sid:')) continue;
+      if (opening.startsWith(k) || (k && k.startsWith(opening))) {
+        return { key: k, source: 'memo-anchor', ...v };
+      }
+    }
+  }
+  return null;
+}
+
+export function rememberSpillMemo(spillMemo, key, entry, { max = 32 } = {}) {
+  if (!spillMemo || !key) return;
+  spillMemo.set(key, entry);
+  while (spillMemo.size > max) spillMemo.delete(spillMemo.keys().next().value);
+}
+
+/**
+ * Decide first-bind vs later-turn recall. No I/O — bindCorpus is injected
+ * by the caller (or mocked in tests).
+ *
+ *   cold-bind     — fire-and-forget first bind; this turn may go unspilled
+ *   await-pending — later turn while that bind is in flight; await, then tail
+ *   recall        — contextId known; send tail (+ optional delta append)
+ */
+export function planConversationBind({ sessionKey, corpus, spillMemo, sessionLedger } = {}) {
+  const key = sessionKey || (corpus ? corpus.slice(0, SPILL_CONTENT_ANCHOR_CHARS) : null);
+  const prior = lookupSpillMemo(spillMemo, sessionLedger, { sessionKey: key, corpus });
+  if (!prior) {
+    return { action: 'cold-bind', send: 'full', key, corpus };
+  }
+  if (prior.pending && !prior.contextId) {
+    return {
+      action: 'await-pending',
+      send: 'tail',
+      key: prior.key || key,
+      corpus,
+      ready: prior.ready,
+    };
+  }
+  if (prior.contextId) {
+    let delta = '';
+    let append = false;
+    if (prior.restored) {
+      append = true;
+    } else if (typeof prior.corpus === 'string' && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
+      delta = corpus.slice(prior.corpus.length);
+      append = true;
+    }
+    return {
+      action: 'recall',
+      send: 'tail',
+      key: prior.key || key,
+      corpus,
+      contextId: prior.contextId,
+      hash: prior.hash,
+      reused: true,
+      append,
+      delta,
+      restored: Boolean(prior.restored),
+    };
+  }
+  return { action: 'cold-bind', send: 'full', key, corpus };
+}
+
+/**
+ * Cut the transcript and plan the conversation bind. Tests use this instead
+ * of standing up the proxy or a live gateway.
+ */
+export function planTranscriptSpill(msgs, {
+  knobs,
+  sessionKey,
+  spillMemo,
+  sessionLedger,
+  corpusChars = 0,
+  adapt = false,
+  persist = false,
+  ...cutOpts
+} = {}) {
+  const adapted = applySpillCut(msgs, {
+    knobs,
+    corpusChars,
+    adapt,
+    persist,
+    ...cutOpts,
+  });
+  const empty = { ...adapted, corpus: '', bindPlan: null };
+  if (adapted.cut <= adapted.firstSpillable) return empty;
+  const corpus = msgs.slice(adapted.firstSpillable, adapted.cut).map(msgText).filter(Boolean).join('\n\n');
+  const bindPlan = planConversationBind({ sessionKey, corpus, spillMemo, sessionLedger });
+  return { ...adapted, corpus, bindPlan };
+}
+
 function stubForCut(msgs, cut, opts) {
   return stubBoundFileResults(msgs, {
     boundFiles: opts.boundFiles,

package/lib/x402.js

@@ -22,7 +22,7 @@ import {
  *                  payTo: "<wallet>", resource, description, maxTimeoutSeconds,
  *                  extra: { facilitator, feePayer, symbol, billedUsd, tokenUsd,
  *                           pricedAt, pricing: "markup"|"counterfactual",
- *                           markup? , directUsd?, savesVsDirect?,
+ *                           billedUsd, directUsd?, savedUsd?, savesVsDirect?,
  *                           acquire?: { method: "spl-token-wrap", steps: WRAP_ACQUIRE_STEPS } } } ],
  *     error: "payment required",
  *     help: "Wrap ix has 9 accounts. Program CPIs the deposit — do not send a separate TransferChecked. 0x6a = NotEnoughAccounts (old 5-account wrap is dead)." }
@@ -232,12 +232,21 @@ export function receiptLine(accept, settle) {
   // reaches the spill threshold, so there is nothing to compress and nothing
   // to save — which is worth saying out loud, because the fix on the caller's
   // side is to BIND a corpus, not to change models.
-  const ratio = x.savesVsDirect != null ? Number(x.savesVsDirect) : null;
+  const billed = Number(x.billedUsd);
+  const direct = x.directUsd != null ? Number(x.directUsd) : null;
+  const saved = x.savedUsd != null ? Number(x.savedUsd)
+    : (Number.isFinite(billed) && Number.isFinite(direct) ? Math.max(0, direct - billed) : null);
+  const ratio = x.savesVsDirect != null ? Number(x.savesVsDirect)
+    : (Number.isFinite(billed) && billed > 0 && Number.isFinite(direct) ? direct / billed : null);
+  // Wallet path: OpenRouter price, plus 33% of savings vs direct when any.
+  // Never print extra.markup — that field is leftover 3× and is not the quote.
   const saves = ratio != null
     ? (ratio >= 1.05
         ? ` (${ratio.toFixed(1)}× cheaper than direct)`
-        : ' (at direct price — nothing to compress; bind a corpus to save)')
-    : (x.markup != null ? ` (markup ${x.markup}×, short body)` : '');
+        : ' (at OpenRouter price — nothing to compress; bind a corpus to save)')
+    : (Number.isFinite(saved) && saved > 0
+        ? ` ($${saved.toFixed(4)} saved vs direct)`
+        : ' (at OpenRouter price — short body)');
   const tx = settle?.transaction || settle?.txHash || settle?.signature;
   const rail = railOf(accept);
   return `paid ${usd}${saves}${rail ? ` · rail ${rail}` : ''}${tx ? ` · tx ${tx}` : ''}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.49.4",
-  "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.",
+  "version": "0.49.6",
+  "description": "Local x402-paying proxy + MCP server for openzoo.fun — 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",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/*.test.js && node scripts/assert-grokui-pin.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",