openzoo 0.48.27 → 0.48.29

package/lib/launch.js

@@ -164,7 +164,16 @@ export async function launchClaude(argv) {
         + `${JSON.stringify(process.execPath)} -e `
         + '\'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{'
         + 'try{const j=JSON.parse(s);'
-        + 'process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  $"+(Number(j.spendUsd)||0).toFixed(4)+"  "+(j.paidCalls||0)+" call"+((j.paidCalls||0)===1?"":"s")+"  \\u00b7 x402")}'
+        // Spend alone is the COST with none of the benefit. The spill figure is
+        // the context that did NOT ride upstream — the thing being paid for.
+        + 'const sp=j.spilled||{};'
+        + 'const tk=Number(sp.tokensApprox)||0;'
+        + 'const ht=tk>=1e6?(tk/1e6).toFixed(1)+"M":tk>=1e3?Math.round(tk/1e3)+"k":String(tk);'
+        + 'const spill=tk?("  \\u00b7 "+ht+" tok offloaded"):"";'
+        // "how can I easily see what credit i'm left" — asked by a user who
+        // could not tell whether x402 had charged them at all.
+        + 'const cr=(j.creditUsd==null)?"":("  \\u00b7 $"+Number(j.creditUsd).toFixed(2)+" credit");'
+        + 'process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  $"+(Number(j.spendUsd)||0).toFixed(4)+"  "+(j.paidCalls||0)+" call"+((j.paidCalls||0)===1?"":"s")+spill+cr+"  \\u00b7 x402")}'
         + 'catch{process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  \\u00b7 x402")}})\'\n');
       fs.chmodSync(scriptPath, 0o755);
       const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
@@ -172,12 +181,30 @@ export async function launchClaude(argv) {
       try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')) || {}; } catch { settings = {}; }
       const prev = settings.statusLine;
       settings.statusLine = { type: 'command', command: `sh ${scriptPath}` };
+      // AUTO-COMPACT OFF — and only correct BECAUSE the proxy spills.
+      //
+      // Claude Code counts the WHOLE local transcript and compacts on its own
+      // ceiling; it cannot know the proxy binds the old prefix into leCore and
+      // forwards only the system block plus the recent tail. So it was
+      // destroying history to stay under a limit the upstream request never
+      // approached — on a product whose pitch is that it does not have to.
+      //
+      // This would have been RECKLESS before spillTranscript existed: with the
+      // full body going upstream, disabling compaction just moves the failure
+      // from a lossy summary to a hard context error. It is safe now precisely
+      // because OPENZOO_KEEP_TAIL_MSGS bounds what is actually sent.
+      // OPENZOO_KEEP_COMPACT=1 restores stock behaviour.
+      const prevCompact = settings.autoCompactEnabled;
+      if (process.env.OPENZOO_KEEP_COMPACT !== '1') settings.autoCompactEnabled = false;
       fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
       fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
       restoreStatus = () => {
         try {
           const cur = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
           if (prev === undefined) delete cur.statusLine; else cur.statusLine = prev;
+          // Never leave a global setting mutated after we exit.
+          if (prevCompact === undefined) delete cur.autoCompactEnabled;
+          else cur.autoCompactEnabled = prevCompact;
           fs.writeFileSync(settingsPath, `${JSON.stringify(cur, null, 2)}\n`);
         } catch { /* leave as-is */ }
       };

package/lib/proxy.js

@@ -304,6 +304,17 @@ async function spillTranscript(body, log) {
   for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
     if (msgs[i]?.role === 'user') { cut = i; break; }
   }
+  // FALL BACK TO THE LAST SEVERABLE TURN. The keepTail window is a preference,
+  // not a requirement: a transcript can be enormous and still have very few
+  // user turns (one huge document, then tool traffic), and on those the window
+  // contained no `user` message at all — so nothing spilled and the whole body
+  // went upstream while the counter honestly reported 0. Keep at least the
+  // final turn; anything earlier that is severable is better than not spilling.
+  if (cut <= firstSpillable) {
+    for (let i = msgs.length - 2; i > firstSpillable; i--) {
+      if (msgs[i]?.role === 'user') { cut = i; break; }
+    }
+  }
   if (cut <= firstSpillable) return null;         // nothing safely severable
 
   const head = msgs.slice(0, firstSpillable);     // system block, always kept
@@ -430,6 +441,27 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // "is the editor really routing through us?" — an editor that silently keeps
   // using its own backend leaves this at 0 while looking perfectly healthy.
   let servedRequests = 0;
+  // SPILL ACCOUNTING. The product's whole claim is that context is offloaded
+  // instead of re-sent, and nothing measured it — the status line showed spend
+  // and call count, which is the cost side with none of the benefit.
+  let spillCalls = 0;
+  let spilledChars = 0;
+  let spillReuses = 0;
+  // CREDIT, CACHED. Users cannot tell prepaid credit from wallet balance and
+  // have to guess whether a call was even paid for ("I don't think x402 made me
+  // pay this at all"). The status line runs EVERY turn, so this is refreshed at
+  // most every 20s and served stale in between — a status line must never add
+  // latency to the thing it is describing.
+  let creditUsd = null;
+  let creditAt = 0;
+  const refreshCredit = () => {
+    if (Date.now() - creditAt < 20000) return;
+    creditAt = Date.now();
+    fetch(`${config.apiBase}/v1/credits`, { headers: withNamespace({}), signal: AbortSignal.timeout(4000) })
+      .then((r) => r.json())
+      .then((j) => { creditUsd = Number(j.balanceUsd) || 0; })
+      .catch(() => { /* advisory only */ });
+  };
   let tunnelError = null;
 
   const server = http.createServer(async (req, res) => {
@@ -523,6 +555,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     {
       const p0 = (req.url || '').split('?')[0];
       if (req.method === 'GET' && (p0 === '/v1/info' || p0 === '/info')) {
+        refreshCredit();
         const self = viaTunnel && tunnelGate?.publicUrl
           ? `${tunnelGate.publicUrl}/v1`
           : `http://localhost:${config.port}/v1`;
@@ -533,7 +566,17 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
           publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
           servedRequests,
+          spilled: {
+            calls: spillCalls,
+            chars: spilledChars,
+            // ~4 chars/token is the usual rough rule; this is the context that
+            // did NOT ride upstream on those calls, which is the number the
+            // saving is actually made of.
+            tokensApprox: Math.round(spilledChars / 4),
+            reusedBinds: spillReuses,
+          },
           spendUsd: sessionSpent,
+          creditUsd,
           paidCalls,
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
@@ -798,6 +841,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       });
       let result;
       if (cached) {
+        spillCalls += 1;
+        spilledChars += cached.corpus?.length || 0;
+        if (cached.reused) spillReuses += 1;
         result = await send(cached.body, cached.contextId);
         // Sidecar wiped between runs: the gateway 404s BEFORE the 402 (nothing
         // paid). Never fail on a stale manifest — re-bind once and retry.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.27",
+  "version": "0.48.29",
   "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",