openzoo 0.48.74 → 0.48.75

package/lib/proxy.js

@@ -749,6 +749,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       mkdirSync(path.dirname(sayFile), { recursive: true });
     } catch { sayFile = null; }
   }
+  // Spill/adapt/classifier lines must use this channel: `log` is a no-op when
+  // `openzoo claude` starts us with silent:true, and printing them on stdout
+  // corrupts the Claude Code TTY. say() writes ~/.openzoo/proxy.log then.
   const say = (...a) => {
     const line = a.join(' ');
     if (sayFile) { try { appendFileSync(sayFile, line + '\n'); return; } catch { /* fall through */ } }
@@ -1187,7 +1190,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         const policy = rewriteChatModel(parsed, ids, { bodyLen: bodyBuf.length });
         parsed = policy.parsed;
         if (policy.tiny) {
-          log(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
+          // `openzoo claude` starts us silent � `log` is a no-op then. say()
+          // is the proxy.log channel and never the Claude Code TTY.
+          say(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
         } else {
           // SAY WHETHER THE OVERRIDE IS ACTUALLY SET, and name it.
           //
@@ -1372,7 +1377,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     try {
       let cached = null;
       try {
-        cached = await maybeCacheCorpus(req, bodyBuf, log, spill);
+        // Spill/adapt diagnostics (adapt, file-stub, sending N/M) must hit
+        // ~/.openzoo/proxy.log when we are silent. `log` is a no-op then.
+        cached = await maybeCacheCorpus(req, bodyBuf, say, spill);
       } catch (err) {
         log(`context cache skipped for this call: ${err.message}`);
       }

package/lib/spill.js

@@ -492,9 +492,26 @@ export function looksLikeFileView(command) {
   return sawView;
 }
 
-export function fileBoundStub(paths) {
+/** Tool result larger than this is "fat" — stub it in the forwarded tail. */
+export const FAT_TOOL_CHARS = 400;
+
+export function fileBoundStub(paths, n) {
   const list = [...new Set((paths || []).filter(Boolean))].join(' ');
-  return list ? `FILE ${list} [bound]` : 'FILE [bound]';
+  const mark = Number.isFinite(n) && n > 0 ? `[bound, ${n} chars]` : '[bound]';
+  return list ? `FILE ${list} ${mark}` : `FILE ${mark}`;
+}
+
+/** Generic stub for WebSearch / Fetch / Bash / any fat tool_result. */
+export function toolResultStub(n, paths) {
+  const list = [...new Set((paths || []).filter(Boolean))].join(' ');
+  const mark = `[bound, ${Number(n) || 0} chars]`;
+  return list ? `FILE ${list} ${mark}` : mark;
+}
+
+function isStubText(content) {
+  if (typeof content === 'string') return /\[bound(?:, \d+ chars)?\]/.test(content);
+  if (Array.isArray(content)) return content.some((b) => isStubText(typeof b === 'string' ? b : b?.text ?? b?.content));
+  return false;
 }
 
 function toolContentLength(content) {
@@ -524,10 +541,15 @@ function resolveBoundPath(raw, cwd, boundAbs) {
  * (live: 5MB filebind, lastSend 13/107, savingX 1.22 instead of ~7x).
  *
  * Cheap rewrite — no disk I/O. First-read results (not yet in boundAbs) and
- * non-file tool output (npm test, grep, …) stay verbatim. The ask stays.
+ * non-file tool output stay verbatim UNLESS `aggressive` / `stubMore` or a
+ * tail `budget` is set. Those two are what beat a WebSearch/Fetch/Bash
+ * storm: the 800-byte floor cannot move `cut` inside a tool chain
+ * (`isSeverable` is false), so the byte budget has to win by stubbing
+ * bodies instead of deleting the tool_use / tool_result pairing.
  *
  * `fromIndex` limits the rewrite to the forwarded tail so the spilled prefix
- * that becomes the conversation corpus is unchanged.
+ * that becomes the conversation corpus is unchanged. The last user ask is
+ * never rewritten.
  */
 export function stubBoundFileResults(msgs, {
   boundFiles,
@@ -536,10 +558,16 @@ export function stubBoundFileResults(msgs, {
   fromIndex = 0,
   // When the live tuner is below target, stub file-view results even if
   // this turn has not yet recorded them in boundAbs (first-read bodies).
+  // Also stubs fat non-file tools (WebSearch / Fetch / Bash).
   aggressive = false,
+  // When the forwarded tail is over this many chars, stub older tool_result
+  // bodies (oldest first) until it fits. Pairing stays; the ask stays.
+  budget = null,
+  fatChars = FAT_TOOL_CHARS,
 } = {}) {
   const absSet = boundAbs || boundAbsFromKeys(boundFiles);
-  if (!Array.isArray(msgs) || (!absSet.size && !aggressive)) {
+  const wantBudget = budget != null && Number.isFinite(Number(budget));
+  if (!Array.isArray(msgs) || (!absSet.size && !aggressive && !wantBudget)) {
     return { messages: msgs, stubbed: 0, dropped: 0 };
   }
 
@@ -585,32 +613,91 @@ export function stubBoundFileResults(msgs, {
     }
   }
 
-  if (!stubIds.size) return { messages: msgs, stubbed: 0, dropped: 0 };
+  const lastUser = lastUserAskIndex(msgs, firstSpillableIndex(msgs));
+  const fatLimit = Number.isFinite(Number(fatChars)) ? Number(fatChars) : FAT_TOOL_CHARS;
+
+  const stubFor = (id, n) => {
+    const paths = idPaths.get(id);
+    return paths?.length ? fileBoundStub(paths, n) : toolResultStub(n);
+  };
+
+  const shouldStubBody = (id, n) => {
+    if (!n || isStubText(typeof n === 'number' ? '' : n)) return false;
+    if (stubIds.has(id)) return true;
+    if (aggressive && n >= fatLimit) return true;
+    return false;
+  };
 
   let stubbed = 0;
   let dropped = 0;
-  const messages = msgs.map((m, i) => {
-    if (i < fromIndex || !m) return m;
-    if (m.role === 'tool' && stubIds.has(m.tool_call_id)) {
+  let messages = msgs.map((m, i) => {
+    if (i < fromIndex || !m || i === lastUser) return m;
+    if (m.role === 'tool') {
       const n = toolContentLength(m.content);
-      if (!n) return m;
+      if (!shouldStubBody(m.tool_call_id, n) || isStubText(m.content)) return m;
       dropped += n;
       stubbed += 1;
-      return { ...m, content: fileBoundStub(idPaths.get(m.tool_call_id)) };
+      return { ...m, content: stubFor(m.tool_call_id, n) };
     }
     if (!Array.isArray(m.content)) return m;
     let changed = false;
     const blocks = m.content.map((b) => {
-      if (b?.type !== 'tool_result' || !stubIds.has(b.tool_use_id)) return b;
+      if (b?.type !== 'tool_result') return b;
       const n = toolContentLength(b.content);
-      if (!n) return b;
+      if (!shouldStubBody(b.tool_use_id, n) || isStubText(b.content)) return b;
       dropped += n;
       stubbed += 1;
       changed = true;
-      return { ...b, content: fileBoundStub(idPaths.get(b.tool_use_id)) };
+      return { ...b, content: stubFor(b.tool_use_id, n) };
     });
     return changed ? { ...m, content: blocks } : m;
   });
+
+  // Byte budget wins inside a tool chain. cutTranscript cannot move tailStart
+  // past assistant(tool_calls) / role:tool (pairing 400s the provider), so a
+  // 15-result storm used to ride in full at the 800-byte floor. Stub older
+  // bodies first; never drop the ask or the assistant tool_calls themselves.
+  if (wantBudget) {
+    const cap = Number(budget);
+    let used = sliceChars(messages, fromIndex);
+    if (used > cap) {
+      const next = messages.slice();
+      for (let i = fromIndex; i < next.length && used > cap; i++) {
+        if (i === lastUser) continue;
+        const m = next[i];
+        if (!m) continue;
+        if (m.role === 'tool') {
+          if (isStubText(m.content)) continue;
+          const n = toolContentLength(m.content);
+          if (!n) continue;
+          const stub = stubFor(m.tool_call_id, n);
+          if (stub.length >= n) continue;
+          used = used - n + stub.length;
+          next[i] = { ...m, content: stub };
+          stubbed += 1;
+          dropped += n;
+          continue;
+        }
+        if (!Array.isArray(m.content)) continue;
+        let changed = false;
+        const blocks = m.content.map((b) => {
+          if (b?.type !== 'tool_result' || used <= cap || isStubText(b.content)) return b;
+          const n = toolContentLength(b.content);
+          if (!n) return b;
+          const stub = stubFor(b.tool_use_id, n);
+          if (stub.length >= n) return b;
+          used = used - n + stub.length;
+          stubbed += 1;
+          dropped += n;
+          changed = true;
+          return { ...b, content: stub };
+        });
+        if (changed) next[i] = { ...m, content: blocks };
+      }
+      messages = next;
+    }
+  }
+
   return { messages, stubbed, dropped };
 }
 
@@ -940,6 +1027,11 @@ export function cutTranscript(msgs, knobs = {}) {
     return { cut: -1, firstSpillable, lastUser: lastUserAskIndex(msgs, firstSpillable), knobs: k };
   }
 
+  // Only moves the cut at a severable index. A current-turn tool storm
+  // (assistant(tool_calls) + N tool results + user ask) has no severable
+  // index inside the chain, so this walk is a no-op — the byte budget is
+  // applied by stubbing bodies in stubBoundFileResults, not by orphaning
+  // a tool_result.
   let tailStart = cut;
   {
     let used = 0;
@@ -979,6 +1071,7 @@ function stubForCut(msgs, cut, opts) {
     cwd: opts.cwd,
     fromIndex: cut,
     aggressive: Boolean(opts.aggressive),
+    budget: opts.budget,
   });
 }
 
@@ -1033,7 +1126,7 @@ export function applySpillCut(msgs, {
     };
   };
 
-  let stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore });
+  let stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget });
   let stats = measure(plan.cut, stubbed, k);
   let action = 'hold';
 
@@ -1049,7 +1142,7 @@ export function applySpillCut(msgs, {
     if (decision.recut) {
       plan = cutTranscript(msgs, k);
       if (plan.cut > plan.firstSpillable) {
-        stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore });
+        stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget });
         stats = measure(plan.cut, stubbed, k);
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.74",
+  "version": "0.48.75",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 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",