openzoo 0.48.51 → 0.48.53

package/lib/proxy.js

@@ -311,7 +311,7 @@ function msgText(m) {
  * 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) {
+async function spillTranscript(body, log, req) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs || msgs.length < 6) return null;
 
@@ -391,6 +391,28 @@ async function spillTranscript(body, log) {
   }
   if (tailStart > cut) cut = tailStart;
 
+  // COHERENCE IS COUNTED IN TURNS, NOT BYTES.
+  //
+  // The byte budget alone produced windows of 2, 5 and 34 turns out of ~600 —
+  // and one fat tool result is enough to spend the whole 6,000 chars, so a busy
+  // agent turn collapses the window to almost nothing. OBSERVED live: an agent
+  // that had just run a command reported "I don't have the preceding turns of
+  // this conversation in view" and re-derived its own state from files, every
+  // turn. Retrieval brings back what is RELEVANT to the ask; it does not
+  // reliably bring back "what I just did", because the model does not know to
+  // query for it.
+  //
+  // So floor the window at a number of turns regardless of size. This costs
+  // saving — a bigger tail is a bigger `sent` — and that is the correct trade:
+  // measured 8.13x on the fleet leaves room to spend some of it on an agent
+  // that remembers its own last few moves.
+  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 12);
+  if (msgs.length - cut < minTurns) {
+    for (let i = Math.max(firstSpillable + 1, msgs.length - minTurns); i > firstSpillable; i--) {
+      if (severable(i)) { cut = i; break; }
+    }
+  }
+
   // NEVER SPILL THE CURRENT ASK.
   //
   // The tail budget walks BACKWARD accumulating bytes, and in an agent loop the
@@ -430,7 +452,29 @@ async function spillTranscript(body, log) {
   // 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);
+  // KEY ON THE SESSION, NOT ON THE CONTENT.
+  //
+  // The anchor was the first 2KB of corpus, which works only because a
+  // transcript's opening never changes. It is fragile in exactly the cases that
+  // matter: two sessions that open identically (same system block, same first
+  // instruction — the norm for an agent) collide onto ONE bound context and
+  // interleave their histories, and any edit near the top of a transcript
+  // silently orphans the binding and re-uploads the whole thing.
+  //
+  // Claude Code identifies its session, so use that when it is offered and fall
+  // back to the content anchor when it is not. Same memo, better key.
+  // CAPTURED FROM A LIVE claude-cli/2.1.232 REQUEST, not guessed. The first
+  // version of this checked x-session-id / x-claude-session-id /
+  // metadata.user_id — none of which Claude Code sends, so it silently fell
+  // back to the content anchor on every request and the feature did nothing.
+  // 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 prior = spillMemo.get(anchor);
   let bind;
   if (prior && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
@@ -463,9 +507,12 @@ async function spillTranscript(body, log) {
   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;
+  // NAME THE KEY. A memo keyed on the wrong thing fails silently — it just
+  // re-binds forever and collides sessions — so the log says which key was used.
+  const keyKind = sessionId ? `sid ${String(sessionId).slice(0, 8)}` : 'content-anchor';
   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`);
+    ? `transcript prefix already bound (${bind.contextId}, ${keyKind}) — sending ${sent}/${msgs.length} turns`
+    : `transcript prefix bound (${mb(bind.bytes)}MB → ${bind.contextId}, ${keyKind}) — sending ${sent}/${msgs.length} turns`);
 
   // ADAPTIVE TOP-K. A fixed 32 chunks is what was actually eating the saving:
   // MEASURED on a 56,265-token corpus, top_k 32 handed 9,990 tokens back and
@@ -515,11 +562,11 @@ async function maybeCacheCorpus(req, bodyBuf, log) {
   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);
+  if (!oneShot) return spillTranscript(body, log, req);
   const cut = last.content.lastIndexOf('\n\n');
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
-  if (!ask || ask.length > 8000) return spillTranscript(body, log);
+  if (!ask || ask.length > 8000) return spillTranscript(body, log, req);
 
   const bind = await bindCorpus(corpus, {
     onStage: (stage, info) => {
@@ -982,6 +1029,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       if ((req.url || '').includes('/chat/completions') && req.method === 'POST') {
         servedRequests += 1;
         say(`\n<- request #${servedRequests} from ${(req.headers['user-agent'] || 'unknown').slice(0, 40)}`);
+        // TEMPORARY: name the headers (not values) so we can see whether the
+        // client offers a session id at all. Values are never logged — several
+        // of these carry auth.
+        if (process.env.OPENZOO_LOG_HEADERS === '1') {
+          log(`  headers: ${Object.keys(req.headers).sort().join(', ')}`);
+        }
       }
     if (rewritablePath(req.method, req.url)) {
       const rw = await maybeRewriteModel(bodyBuf);

package/package.json

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