openzoo 0.48.32 → 0.48.34

package/lib/proxy.js

@@ -300,9 +300,31 @@ async function spillTranscript(body, log) {
   const firstSpillable = msgs.findIndex((m) => m?.role !== 'system');
   if (firstSpillable < 0) return null;
 
+  // A SEVERABLE BOUNDARY IS NOT ONLY A `user` TURN.
+  //
+  // That was the whole bug: in a Claude Code agent loop the human speaks ONCE
+  // and everything after is assistant->tool pairs, so a rule that only cuts at
+  // role:"user" finds nothing and the spill returns null on EVERY turn.
+  // MEASURED against the live proxy log: 104 real claude-cli requests, zero
+  // spills, while every synthetic transcript I tested spilled fine because I
+  // had written user turns into it.
+  //
+  // What actually matters is that no assistant `tool_calls` is left unanswered
+  // across the cut. So any message is a legal boundary when the one BEFORE it
+  // is not an unanswered tool call — i.e. the previous message is a plain
+  // assistant/user/tool with every call already resolved.
+  const severable = (i) => {
+    if (i <= firstSpillable || i >= msgs.length) return false;
+    const prev = msgs[i - 1];
+    if (!prev) return false;
+    // an assistant that issued tool_calls must be followed by its tool results
+    if (prev.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length) return false;
+    // never split a tool_call/tool_result run in the middle
+    return msgs[i].role !== 'tool';
+  };
   let cut = -1;
   for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
-    if (msgs[i]?.role === 'user') { cut = i; break; }
+    if (severable(i)) { 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
@@ -312,11 +334,33 @@ async function spillTranscript(body, log) {
   // 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 (severable(i)) { cut = i; break; }
     }
   }
   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;

package/package.json

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