openzoo 0.48.60 → 0.48.62

package/lib/proxy.js

@@ -119,6 +119,9 @@ const spillMemo = new Map();
 // path:mtime of every file already bound — a file is bound once per version,
 // never re-uploaded because the agent read it again.
 const boundFiles = new Set();
+// context_id -> total chars BOUND (turns + files appended). The counterfactual
+// basis must reflect what the corpus actually holds, not just this turn's slice.
+const boundChars = new Map();
 
 /**
  * Every fundable balance across all three chains, for the startup line and
@@ -519,10 +522,56 @@ async function spillTranscript(body, log, req) {
     return out.join('\n\n');
   };
 
+  // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
+  //
+  // The FIRST bind of a session is necessarily synchronous — the request cannot
+  // go until the context_id exists, because it travels as x-hrr-context. Folding
+  // file bytes into that bind put a 400KB upload in front of the caller's turn,
+  // which is the cold-bind stall this whole exercise was meant to remove: the
+  // bind endpoint measures 0.34-0.48s on a 613KB corpus, and that is 0.34-0.48s
+  // the user waits before a single token appears.
+  //
+  // Nothing recalls a file during the turn that read it — the model already has
+  // the tool result in its window. Files are only worth having bound for the
+  // NEXT ask. So the conversation binds inline and the files are appended after
+  // the fact, off the clock.
   const turns = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
   const files = filesForCorpus();
-  const corpus = files ? `${turns}\n\n${files}` : turns;
-  if (corpus.length <= BIND_MIN_CHARS) return null;
+  const corpus = turns;
+
+  // FILES BIND EVEN WHEN THE CONVERSATION IS TOO SMALL TO SPILL.
+  //
+  // The threshold exists to stop us binding a two-line chat — it was never
+  // meant to gate FILES. But bailing here skipped them entirely, so a fresh
+  // session that reads a 200KB file bound nothing and scored 1.00x forever:
+  // OBSERVED on a live session that read files all turn and never produced a
+  // corpus, because its conversation stayed under the threshold the whole time.
+  //
+  // A file is worth binding on its own merit. So when the turns are too small
+  // to spill but files exist, bind the files anyway — in the background,
+  // against this session's context — and let this turn go unspilled. The corpus
+  // is then waiting for the next ask.
+  const sessionId = req?.headers?.['x-claude-code-session-id']
+    || req?.headers?.['x-session-id']
+    || req?.headers?.['x-claude-session-id']
+    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
+  const sessionKey = sessionId ? `sid:${sessionId}` : corpus.slice(0, 2048);
+  if (corpus.length <= BIND_MIN_CHARS) {
+    if (files) {
+      const known = spillMemo.get(sessionKey);
+      void bindCorpus(files, {
+        appendTo: known?.contextId || null,
+        onStage: (stage, info) => {
+          if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of FILES (conversation under spill threshold, background)`);
+        },
+      }).then((b) => {
+        if (!b?.contextId) return;
+        boundChars.set(b.contextId, (boundChars.get(b.contextId) || 0) + files.length);
+        if (!known) spillMemo.set(sessionKey, { corpus, contextId: b.contextId, hash: b.hash });
+      }).catch((e) => log(`file bind failed: ${e.message}`));
+    }
+    return null;
+  }
 
   // CONTINUE THE CONTEXT, BIND ONLY THE DELTA.
   //
@@ -554,11 +603,7 @@ async function spillTranscript(body, log, req) {
   // The real header list is:
   //   anthropic-beta, anthropic-version, x-app, x-claude-code-session-id,
   //   x-stainless-*
-  const sessionId = req?.headers?.['x-claude-code-session-id']
-    || req?.headers?.['x-session-id']
-    || req?.headers?.['x-claude-session-id']
-    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
-  const anchor = sessionId ? `sid:${sessionId}` : corpus.slice(0, 2048);
+  const anchor = sessionKey;
   const prior = spillMemo.get(anchor);
   let bind;
   if (prior && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
@@ -588,6 +633,19 @@ async function spillTranscript(body, log, req) {
       },
     });
   }
+  // APPEND THE FILES AFTER, off the clock. Fire-and-forget against the context
+  // we just secured: this turn is already answerable without them, and the next
+  // ask gets them for free. `boundFiles` already deduped by path:mtime, so this
+  // uploads each version exactly once no matter how often the agent re-reads it.
+  if (files) {
+    boundChars.set(bind.contextId, (boundChars.get(bind.contextId) || corpus.length) + files.length);
+    void bindCorpus(files, {
+      appendTo: bind.contextId,
+      onStage: (stage, info) => {
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB of FILES to ${bind.contextId} (background)`);
+      },
+    }).catch((e) => log(`file append failed (corpus lags one turn): ${e.message}`));
+  }
   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;
@@ -1266,7 +1324,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       } catch (err) {
         log(`context cache skipped for this call: ${err.message}`);
       }
-      const send = (buf, ctxId, topK) => client.fetch(url, {
+      const send = (buf, ctxId, topK, corpusChars) => client.fetch(url, {
         ...init,
         body: buf,
         headers: ctxId
@@ -1275,6 +1333,16 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             'x-hrr-context': ctxId,
             // Only on the spill path — a caller that set its own top-k keeps it.
             ...(topK ? { 'x-hrr-top-k': String(topK) } : {}),
+            // TELL THE GATEWAY HOW BIG THE CORPUS IS. It has been guessing:
+            // `contextChars` is populated only when a bind passes through the
+            // gateway itself, so on an APPEND — and on every corpus that
+            // includes files the agent read, which never appear in a request
+            // body at all — it has no idea and falls back to the body size.
+            // That is why the counterfactual logged `corpus ?` all day and why
+            // a call whose corpus held 40,777 tokens priced as if it held
+            // 4,303. The proxy assembled the corpus; it is the only party that
+            // knows.
+            ...(corpusChars ? { 'x-hrr-corpus-chars': String(corpusChars) } : {}),
           }
           : init.headers,
       });
@@ -1285,7 +1353,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         didSpill = true;
         spilledChars += cached.corpus?.length || 0;
         if (cached.reused) spillReuses += 1;
-        result = await send(cached.body, cached.contextId, cached.topK);
+        result = await send(cached.body, cached.contextId, cached.topK, boundChars.get(cached.contextId) || cached.corpus?.length);
         // Sidecar wiped between runs: the gateway 404s BEFORE the 402 (nothing
         // paid). Never fail on a stale manifest — re-bind once and retry.
         if (result.response.status === 404) {
@@ -1294,7 +1362,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             log('bound context is gone on the zoo — re-binding once...');
             forgetContext(config.apiBase, cached.hash);
             const rebound = await bindCorpus(cached.corpus, { force: true });
-            result = await send(cached.body, rebound.contextId, cached.topK);
+            result = await send(cached.body, rebound.contextId, cached.topK, boundChars.get(rebound.contextId) || cached.corpus?.length);
           } else {
             res.writeHead(404, { 'content-type': 'application/json' });
             res.end(text);

package/package.json

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