openzoo 0.48.26 → 0.48.28

package/lib/launch.js

@@ -164,7 +164,13 @@ 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"):"";'
+        + '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+"  \\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 +178,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

@@ -245,6 +245,102 @@ function replayPut(key, data, settle) {
  * to sending the original body untouched — caching must never break a call.
  * Returns null (send as-is) or { body, contextId, hash, corpus, reused, savedBytes }.
  */
+/** Flatten one Anthropic content block to text leCore can index. */
+function blockText(b) {
+  if (typeof b === 'string') return b;
+  if (!b || typeof b !== 'object') return '';
+  if (b.type === 'text') return b.text || '';
+  if (b.type === 'tool_use') return `[tool_use ${b.name}] ${JSON.stringify(b.input ?? {})}`;
+  if (b.type === 'tool_result') {
+    const c = b.content;
+    return `[tool_result] ${typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).join('\n') : JSON.stringify(c ?? ''))}`;
+  }
+  if (b.type === 'thinking') return '';        // never bind reasoning traces
+  return '';
+}
+
+function msgText(m) {
+  const c = m?.content;
+  const body = typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).filter(Boolean).join('\n') : '');
+  return body ? `${(m.role || '?').toUpperCase()}: ${body}` : '';
+}
+
+/**
+ * Spill the OLD prefix of a long TRANSCRIPT into leCore.
+ *
+ * WHY THIS EXISTS. The only spill was the corpus+question shape below, which
+ * requires the last message to be one big string ending in `\n\n<question>` —
+ * true for zoo_ask, never true for an agent. `npx openzoo claude` therefore
+ * spilled NOTHING, hit Claude Code's own context ceiling, and auto-compacted,
+ * on a product whose pitch is that it does not have to. Compaction was honest
+ * given nothing was offloaded; this is what makes the claim true.
+ *
+ * Runs on the OpenAI shape ON PURPOSE. /v1/messages is translated by
+ * anthropicToOpenAI and rewritten to /v1/chat/completions BEFORE this is
+ * reached, so operating here covers Claude Code, Cursor and the raw API with
+ * one implementation instead of three that can drift.
+ *
+ * THE CUT POINT IS NOT NEGOTIABLE. An assistant `tool_calls` must be answered
+ * by role:"tool" messages or the upstream 400s, so the transcript may only be
+ * severed at a plain `user` message — everything before one is self-contained.
+ * A system message is never spilled: it is the operating contract, not history.
+ */
+async function spillTranscript(body, log) {
+  const msgs = Array.isArray(body?.messages) ? body.messages : null;
+  if (!msgs || msgs.length < 6) return null;
+
+  // Keep the recent tail, but never more than half the transcript: a fixed 8 on
+  // a 10-message body left only index 2 to search, which is rarely a user turn,
+  // so a SHORT-but-huge transcript (one giant tool_result) silently never
+  // spilled — the exact case an agent hits first.
+  const keepTail = Math.min(
+    Number(process.env.OPENZOO_KEEP_TAIL_MSGS || 8),
+    Math.max(2, Math.floor(msgs.length / 2)),
+  );
+  const firstSpillable = msgs.findIndex((m) => m?.role !== 'system');
+  if (firstSpillable < 0) return null;
+
+  let cut = -1;
+  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
+  const corpus = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
+  if (corpus.length <= BIND_MIN_CHARS) return null;
+
+  const bind = await bindCorpus(corpus, {
+    onStage: (stage, info) => {
+      if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of transcript to holographic memory...`);
+    },
+  });
+  const sent = msgs.length - cut;
+  log(bind.reused
+    ? `transcript prefix already bound (${bind.contextId}) — sending ${sent}/${msgs.length} turns`
+    : `transcript prefix bound (${mb(bind.bytes)}MB → ${bind.contextId}) — sending ${sent}/${msgs.length} turns`);
+
+  return {
+    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),
+    contextId: bind.contextId,
+    hash: bind.hash,
+    corpus,
+    reused: bind.reused,
+    savedBytes: bind.bytes,
+  };
+}
+
 async function maybeCacheCorpus(req, bodyBuf, log) {
   if (contextCacheDisabled()) return null;
   if (req.method !== 'POST' || !(req.url || '').includes('/chat/completions')) return null;
@@ -254,13 +350,19 @@ async function maybeCacheCorpus(req, bodyBuf, log) {
   try { body = JSON.parse(bodyBuf.toString('utf8')); } catch { return null; }
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return null;
+  // CORPUS+QUESTION first — one huge final message ending in \n\n<ask>. That is
+  // what zoo_ask and the chat surface send, and binding exactly that body keeps
+  // the ask verbatim. Anything else (an agent transcript) falls through to the
+  // transcript spill, which used to be a silent no-op.
   const last = msgs[msgs.length - 1];
-  if (typeof last?.content !== 'string' || last.content.length <= BIND_MIN_CHARS) return null;
+  const oneShot = typeof last?.content === 'string'
+    && last.content.length > BIND_MIN_CHARS
+    && last.content.lastIndexOf('\n\n') >= BIND_MIN_CHARS;
+  if (!oneShot) return spillTranscript(body, log);
   const cut = last.content.lastIndexOf('\n\n');
-  if (cut < BIND_MIN_CHARS) return null;
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
-  if (!ask || ask.length > 8000) return null;
+  if (!ask || ask.length > 8000) return spillTranscript(body, log);
 
   const bind = await bindCorpus(corpus, {
     onStage: (stage, info) => {
@@ -339,6 +441,12 @@ 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;
   let tunnelError = null;
 
   const server = http.createServer(async (req, res) => {
@@ -442,6 +550,15 @@ 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,
           paidCalls,
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
@@ -707,6 +824,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.26",
+  "version": "0.48.28",
   "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",