openzoo 0.48.33 → 0.48.35

package/lib/hrr.js

@@ -26,7 +26,7 @@ export const contextCacheDisabled = () => process.env.OPENZOO_NO_CONTEXT_CACHE =
  * Ensure `corpus` is bound on the zoo. Returns
  * { contextId, hash, reused, bytes } — reused=true means zero bytes shipped.
  */
-export async function bindCorpus(corpus, { onStage, force = false } = {}) {
+export async function bindCorpus(corpus, { onStage, force = false, appendTo = null } = {}) {
   const hash = corpusHash(corpus);
   const bytes = Buffer.byteLength(corpus);
   if (!force) {
@@ -37,7 +37,11 @@ export async function bindCorpus(corpus, { onStage, force = false } = {}) {
     }
   }
   onStage?.('binding', { bytes });
-  const r = await postWithUploadSignal(`${config.apiBase}/v1/hrr/bind`, JSON.stringify({ corpus }), {
+  // APPEND, don't re-upload. The gateway takes context_id on /v1/hrr/bind and
+  // adds to that context — which is the difference between paying for the
+  // delta and paying for the whole transcript again on every single turn.
+  const r = await postWithUploadSignal(`${config.apiBase}/v1/hrr/bind`,
+    JSON.stringify(appendTo ? { corpus, context_id: appendTo } : { corpus }), {
     headers: withNamespace(),
     onUploaded: () => onStage?.('bound-uploading-done', { bytes }),
   });

package/lib/proxy.js

@@ -90,6 +90,9 @@ function jsonErr(res, status, message, extraFields = {}) {
 
 const mb = (n) => (n / 1048576).toFixed(1);
 
+// anchor -> { corpus, contextId, hash } for append-only transcript spills
+const spillMemo = new Map();
+
 /**
  * Every fundable balance across all three chains, for the startup line and
  * the live refresh. Each read is independent and advisory — one lagging RPC
@@ -339,15 +342,65 @@ async function spillTranscript(body, log) {
   }
   if (cut <= firstSpillable) return null;         // nothing safely severable
 
+  // TRIM THE TAIL BY BYTES, NOT MESSAGE COUNT.
+  //
+  // MEASURED on the live session: 9 kept turns of Claude Code tool output made
+  // promptTokens swamp the counterfactual and the call scored 1.00x, while the
+  // SAME bound context with a one-line ask scored 8.53x. Nine messages is a
+  // trivial number and an enormous payload — a single Read or grep result is
+  // tens of KB — so counting messages measures the wrong thing entirely.
+  //
+  // Walk backwards from the newest and stop at a byte budget. The newest turns
+  // are the ones the model actually needs verbatim; everything older is already
+  // in the bound corpus and comes back through recall.
+  let tailStart = cut;
+  {
+    const budget = Number(process.env.OPENZOO_TAIL_MAX_CHARS || 24000);
+    let used = 0;
+    for (let i = msgs.length - 1; i >= cut; i--) {
+      used += msgText(msgs[i]).length;
+      if (used > budget && severable(i)) { tailStart = i; break; }
+    }
+  }
+  if (tailStart > cut) cut = tailStart;
+
   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...`);
-    },
-  });
+  // CONTINUE THE CONTEXT, BIND ONLY THE DELTA.
+  //
+  // 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
+  // each time, while only a few KB was actually new. Bind cost grew with
+  // conversation length and was re-paid per message.
+  //
+  // The corpus is append-only: each turn's corpus starts with the previous
+  // one. So when it does, send just the tail and keep the same context_id.
+  // Anchored on the FIRST 2KB, which is stable for the life of a conversation
+  // and distinguishes concurrent ones.
+  const anchor = corpus.slice(0, 2048);
+  const prior = spillMemo.get(anchor);
+  let bind;
+  if (prior && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
+    const delta = corpus.slice(prior.corpus.length);
+    await bindCorpus(delta, {
+      appendTo: prior.contextId,
+      onStage: (stage, info) => {
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${prior.contextId} (delta only)`);
+      },
+    });
+    bind = { contextId: prior.contextId, hash: prior.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...`);
+      },
+    });
+  }
+  spillMemo.set(anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
+  if (spillMemo.size > 32) spillMemo.delete(spillMemo.keys().next().value);
   const sent = msgs.length - cut;
   log(bind.reused
     ? `transcript prefix already bound (${bind.contextId}) — sending ${sent}/${msgs.length} turns`

package/package.json

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