openzoo 0.48.34 → 0.48.36

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
@@ -365,11 +368,50 @@ async function spillTranscript(body, log) {
   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);
+    // 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,
+      onStage: (stage, info) => {
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${prior.contextId} (delta, background)`);
+      },
+    }).catch((e) => log(`append failed (history may lag one turn): ${e.message}`));
+    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.34",
+  "version": "0.48.36",
   "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",