openzoo 0.48.56 → 0.48.58

package/lib/proxy.js

@@ -406,10 +406,36 @@ async function spillTranscript(body, log, req) {
   // 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; }
+  // 12 was set while the model was ALSO missing its own last turn to a brief
+  // spliced in behind it (fixed in 0.48.56), so part of that floor was paying
+  // for a bug rather than for coherence. 6 turns still covers "what did I just
+  // do" — the case retrieval cannot answer, because the model does not know to
+  // query for it — and hands the rest back as saving.
+  // COUNT CONVERSATION TURNS, NOT MESSAGES.
+  //
+  // A tool round trip is TWO messages (assistant tool_call + tool result), so a
+  // floor of 6 messages is three tool calls and nothing else — the agent loses
+  // the human turn that started the run and every decision it made along the
+  // way. OBSERVED: "it's when he calls a bunch of tools, he gets lost."
+  //
+  // So the floor is measured in user/assistant turns and tool traffic rides
+  // along for free. A tool-heavy stretch therefore widens the window instead of
+  // consuming it, which is the opposite of the old behaviour and the whole
+  // point: what the agent needs verbatim is what it DID, and doing things is
+  // exactly what fills the window with tool messages.
+  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 6);
+  const realTurns = (from) => {
+    let n = 0;
+    for (let i = from; i < msgs.length; i++) {
+      const r = msgs[i]?.role;
+      if (r === 'user' || r === 'assistant') n += 1;
+    }
+    return n;
+  };
+  if (realTurns(cut) < minTurns) {
+    for (let i = cut - 1; i > firstSpillable; i--) {
+      if (severable(i) && realTurns(i) >= minTurns) { cut = i; break; }
+      if (i === firstSpillable + 1) { if (severable(i)) cut = i; break; }
     }
   }
 
@@ -534,12 +560,18 @@ async function spillTranscript(body, log, req) {
   // far less context than a detailed one — and is clamped so a huge ask cannot
   // drag the whole corpus back in.
   const askChars = msgText(msgs[msgs.length - 1] || {}).length;
+  // BREADTH IS THE LEVER, AND MORE OF IT IS WORSE. MEASURED on a 56,265-token
+  // corpus: top_k 32 handed back 9,990 tokens and scored 2.45x, top_k 8 handed
+  // back 2,574 and scored 4.73x — same question, same answer, nearly double the
+  // saving. Spilling 34k tokens to recall 22k of them back is a round trip, not
+  // a saving. So budget the recall tighter and cap k where the measurement says
+  // the value is, rather than at the largest number that still fits.
   const budget = Math.min(
-    Number(process.env.OPENZOO_RECALL_MAX_TOKENS || 6000),
-    Math.max(Number(process.env.OPENZOO_RECALL_MIN_TOKENS || 1500),
-             Math.round(askChars / 2)),
+    Number(process.env.OPENZOO_RECALL_MAX_TOKENS || 3000),
+    Math.max(Number(process.env.OPENZOO_RECALL_MIN_TOKENS || 1200),
+             Math.round(askChars / 3)),
   );
-  const topK = Math.max(4, Math.min(32, Math.round(budget / 320)));
+  const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
 
   return {
     body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),

package/package.json

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