openzoo 0.48.71 → 0.48.72

package/lib/proxy.js

@@ -13,7 +13,8 @@ import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
-  loadBoundChars, noteCorpusLedger, filesForCorpus, createSpillStats, corpusCharsForSend,
+  loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
+  stubBoundFileResults, createSpillStats, corpusCharsForSend,
 } from './spill.js';
 import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -374,11 +375,18 @@ async function spillTranscript(body, log, req, stats) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return null;
 
-  // FILES FIRST. The cut/length gates below used to run before filesForCorpus,
-  // so a short agent turn that Read a file never bound it � and when the
-  // extract itself returned empty, nothing logged. Extract + log unconditionally.
-  const fileResult = filesForCorpus(msgs, { boundFiles, log });
-  const files = fileResult.text;
+  // PATHS FIRST, BYTES LATER. The cut/length gates below used to run before
+  // filesForCorpus, so a short agent turn that Read a file never bound it �
+  // and when the extract itself returned empty, nothing logged. Collect
+  // unconditionally, but only paths + cheap stat/mtime: a 2MB Read must not
+  // stall this turn. readdir + readFile + bindCorpus run after we return,
+  // via setImmediate, so the chat request goes first.
+  //
+  // Snapshot bound paths BEFORE collect so this turn's first-read files stay
+  // verbatim in the tail (not yet in the corpus for recall). Previously
+  // bound files get their tool_result bodies stubbed at return time.
+  const previouslyBoundAbs = boundAbsFromKeys(boundFiles);
+  const fileCollect = filesForCorpus(msgs, { boundFiles });
   const sessionId = req?.headers?.['x-claude-code-session-id']
     || req?.headers?.['x-session-id']
     || req?.headers?.['x-claude-session-id']
@@ -386,31 +394,46 @@ async function spillTranscript(body, log, req, stats) {
   let sessionKey = sessionId ? `sid:${sessionId}` : null;
 
   const ledgerOpts = () => ({ sessionKey, sessions: sessionLedger, boundFiles });
-  const bindFilesInBackground = (label) => {
-    if (!files) return;
+  const bindFilesInBackground = (label, { appendTo: forcedAppend, asAppend = false } = {}) => {
+    if (!fileCollect.pending.length) return;
     const known = (sessionKey && spillMemo.get(sessionKey))
       || (sessionKey && sessionLedger.get(sessionKey))
       || null;
-    const appendTo = known?.contextId || null;
-    void bindCorpus(files, {
-      appendTo,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`binding ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES (${label})`);
-      },
-    }).then((b) => {
-      if (!b?.contextId) return;
-      noteCorpusLedger(boundChars, {
-        contextId: b.contextId,
-        reused: Boolean(appendTo),
-        corpusChars: 0,
-        fileChars: files.length,
-        ...ledgerOpts(),
-      });
-      stats?.noteFileBind(fileResult.files, fileResult.bytes);
-      if (sessionKey && !spillMemo.has(sessionKey)) {
-        spillMemo.set(sessionKey, { corpus: '', contextId: b.contextId, hash: b.hash });
+    const appendTo = forcedAppend !== undefined ? forcedAppend : (known?.contextId || null);
+    setImmediate(() => {
+      let read;
+      try {
+        read = readFilesForCorpus(fileCollect, { boundFiles, log });
+      } catch (e) {
+        log(`${asAppend ? 'file append failed (corpus lags one turn)' : 'file bind failed'}: ${e.message}`);
+        return;
       }
-    }).catch((e) => log(`file bind failed: ${e.message}`));
+      if (!read.text) return;
+      void bindCorpus(read.text, {
+        appendTo,
+        onStage: (stage, info) => {
+          if (stage !== 'binding') return;
+          if (asAppend && appendTo) {
+            log(`appending ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES to ${appendTo} (background)`);
+          } else {
+            log(`binding ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES (${label})`);
+          }
+        },
+      }).then((b) => {
+        if (!b?.contextId) return;
+        noteCorpusLedger(boundChars, {
+          contextId: b.contextId,
+          reused: Boolean(appendTo),
+          corpusChars: 0,
+          fileChars: read.bytes,
+          ...ledgerOpts(),
+        });
+        stats?.noteFileBind(read.files, read.bytes);
+        if (sessionKey && !spillMemo.has(sessionKey)) {
+          spillMemo.set(sessionKey, { corpus: '', contextId: b.contextId, hash: b.hash });
+        }
+      }).catch((e) => log(`${asAppend ? 'file append failed (corpus lags one turn)' : 'file bind failed'}: ${e.message}`));
+    });
   };
 
   if (msgs.length < 6) {
@@ -583,8 +606,9 @@ async function spillTranscript(body, log, req, stats) {
   // sitting on this machine. Binding it makes the corpus large immediately
   // instead of eventually, and makes the truncated read whole again.
   //
-  // Read-only, bounded, deduped by path+mtime. Path extraction + the file-bind
-  // log already ran at the top of this function (files / fileResult).
+  // Read-only, bounded, deduped by path+mtime. Path collection already ran at
+  // the top of this function (fileCollect.pending). Bytes + dir expansion
+  // happen in bindFilesInBackground after this turn is forwarded.
   //
   // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
   //
@@ -709,22 +733,15 @@ async function spillTranscript(body, log, req, stats) {
     reused: appended,
     corpusChars: corpus.length,
     deltaChars,
-    fileChars: files.length,
+    fileChars: 0,
     ...ledgerOpts(),
   });
   // 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) {
-    stats?.noteFileBind(fileResult.files, fileResult.bytes);
-    void bindCorpus(files, {
-      appendTo: bind.contextId,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES to ${bind.contextId} (background)`);
-      },
-    }).catch((e) => log(`file append failed (corpus lags one turn): ${e.message}`));
-  }
+  // Read + readdir are inside setImmediate � they must not run before send().
+  bindFilesInBackground('background', { appendTo: bind.contextId, asAppend: true });
   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;
@@ -742,6 +759,22 @@ async function spillTranscript(body, log, req, stats) {
     ? `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`);
 
+  // STUB BOUND FILE BODIES IN THE TAIL.
+  //
+  // Tests bind a 250k pile and send a one-line ask: 7x. Live Claude Code
+  // still forwards the last ~13 turns, which are Read/Bash tool_results of
+  // those same files. Sent ~= corpus, so counterfactualTokens > promptTokens
+  // barely fires and dollars stay ~1.2x with 5MB already bound. After a file
+  // is bound, drop its bytes from the forwarded tail (path + marker only).
+  // First-read results and non-file tool output stay verbatim. No disk I/O.
+  const stubbed = stubBoundFileResults(msgs, {
+    boundAbs: previouslyBoundAbs,
+    fromIndex: cut,
+  });
+  if (stubbed.dropped) {
+    log(`file-stub stubbed=${stubbed.stubbed} dropped=${stubbed.dropped}`);
+  }
+
   // 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
   // scored 2.45x, while 8 handed back 2,574 and scored 4.73x — same answer,
@@ -769,7 +802,7 @@ async function spillTranscript(body, log, req, stats) {
   const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
 
   return {
-    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),
+    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...stubbed.messages.slice(cut)] })),
     topK,
     contextId: bind.contextId,
     hash: bind.hash,

package/lib/spill.js

@@ -273,15 +273,39 @@ function fileBindLog({ kept, bytes, enoent, cap, dir, rel, bash }) {
   return `file-bind kept=${kept} bytes=${bytes} skip enoent=${enoent} cap=${cap} dir=${dir} rel=${rel} bash=${bash}`;
 }
 
+function emptyFileBind({ reason = 'none-kept', ...extra } = {}) {
+  return {
+    text: '',
+    files: 0,
+    bytes: 0,
+    pending: [],
+    kept: 0,
+    enoent: 0,
+    cap: 0,
+    dir: 0,
+    rel: 0,
+    bash: 0,
+    reason,
+    ...extra,
+  };
+}
+
 /**
- * Read every new file the agent touched and return the corpus slice to bind.
+ * Request-path filebind: collect paths + cheap stat/mtime only.
  *
  * Live path is OpenAI tool_calls (Read/Edit/Write + Bash command). Relative
  * paths resolve against cwd / last "current working directory is …" hint.
- * Directories expand to children that are files under the cap.
  *
- * Always logs `file-bind kept=N bytes=B skip enoent=X cap=Y dir=Z rel=W bash=K`
- * so grep-for-FILES is no longer the only signal. Bytes, not 0.0MB.
+ * MUST NOT read file contents and MUST NOT readdir children. A 2MB Read
+ * (or a directory the agent listed) used to stall the chat turn here.
+ * Bytes, directory expansion, and bindCorpus belong in readFilesForCorpus,
+ * which the proxy runs after the turn is already on the wire.
+ *
+ * Dedupes on path+mtime into `boundFiles`, applies the size cap, and
+ * reserves directory keys so the same tree is not re-queued every turn.
+ * The `file-bind kept=N bytes=B …` line is logged here only when there is
+ * nothing to read (disabled / none-kept) — otherwise readFilesForCorpus
+ * fills bytes after the background read, never on the hot path.
  */
 export function filesForCorpus(msgs, {
   boundFiles,
@@ -290,13 +314,11 @@ export function filesForCorpus(msgs, {
   disabled = process.env.OPENZOO_BIND_FILES === '0',
   log = () => {},
   statSync = (p) => fs.statSync(p),
-  readFileSync = (p) => fs.readFileSync(p, 'utf8'),
-  readdirSync = (p) => fs.readdirSync(p),
 } = {}) {
-  const empty = { kept: 0, bytes: 0, enoent: 0, cap: 0, dir: 0, rel: 0, bash: 0 };
   if (disabled) {
+    const empty = emptyFileBind({ reason: 'disabled' });
     log(fileBindLog(empty));
-    return { text: '', files: 0, bytes: 0, reason: 'disabled', ...empty };
+    return empty;
   }
   const { structured, bash } = extractFileCandidates(msgs, { cwd });
   const candidates = [
@@ -305,24 +327,19 @@ export function filesForCorpus(msgs, {
   ];
   const skip = { enoent: 0, cap: 0, dir: 0, rel: 0 };
   const seen = new Set();
-  const chunks = [];
+  const pending = [];
 
-  const tryBind = (abs) => {
+  const queue = (abs) => {
     if (!abs || seen.has(abs)) return;
     seen.add(abs);
     let st;
     try { st = statSync(abs); } catch { skip.enoent += 1; return; }
     if (st.isDirectory()) {
       skip.dir += 1;
-      let kids = [];
-      try { kids = readdirSync(abs); } catch { skip.enoent += 1; return; }
-      for (const name of kids) {
-        if (!name || name.startsWith('.') || SKIP_DIR_NAMES.has(name)) continue;
-        const kid = path.join(abs, name);
-        let ks;
-        try { ks = statSync(kid); } catch { skip.enoent += 1; continue; }
-        if (ks.isFile()) tryBind(kid);
-      }
+      const key = `${abs}:${st.mtimeMs}`;
+      if (boundFiles?.has(key)) return;
+      boundFiles?.add(key);
+      pending.push({ abs, kind: 'dir' });
       return;
     }
     if (!st.isFile()) { skip.enoent += 1; return; }
@@ -330,11 +347,7 @@ export function filesForCorpus(msgs, {
     const key = `${abs}:${st.mtimeMs}`;
     if (boundFiles?.has(key)) return;
     boundFiles?.add(key);
-    try {
-      chunks.push(`FILE ${abs}\n${readFileSync(abs)}`);
-    } catch {
-      skip.enoent += 1;
-    }
+    pending.push({ abs, kind: 'file' });
   };
 
   for (const item of candidates) {
@@ -342,7 +355,92 @@ export function filesForCorpus(msgs, {
     if (!path.isAbsolute(raw) && !(raw.startsWith('~/') || raw === '~')) skip.rel += 1;
     const abs = resolveReadablePath(raw, item.cwd || cwd);
     if (!abs) { skip.enoent += 1; continue; }
-    tryBind(abs);
+    queue(abs);
+  }
+
+  const stats = {
+    kept: 0,
+    bytes: 0,
+    enoent: skip.enoent,
+    cap: skip.cap,
+    dir: skip.dir,
+    rel: skip.rel,
+    bash: bash.length,
+  };
+  if (!pending.length) log(fileBindLog(stats));
+  return {
+    text: '',
+    files: 0,
+    bytes: 0,
+    pending,
+    reason: pending.length ? null : 'none-kept',
+    ...stats,
+  };
+}
+
+/**
+ * Background filebind: expand directories, read bytes, log the real totals.
+ *
+ * Takes the `pending` list (or the whole collect result) from filesForCorpus.
+ * Children of a directory skip node_modules/.git/dist/build/__pycache__/.venv/target
+ * and hidden names. Same size cap as the request-path collector.
+ *
+ * Always logs `file-bind kept=N bytes=B skip enoent=X cap=Y dir=Z rel=W bash=K`
+ * so grep-for-FILES is no longer the only signal. Bytes, not 0.0MB.
+ */
+export function readFilesForCorpus(collected, {
+  boundFiles,
+  cap = Number(process.env.OPENZOO_BIND_FILE_MAX || 400_000),
+  log = () => {},
+  statSync = (p) => fs.statSync(p),
+  readFileSync = (p) => fs.readFileSync(p, 'utf8'),
+  readdirSync = (p) => fs.readdirSync(p),
+} = {}) {
+  const pending = Array.isArray(collected) ? collected : (collected?.pending || []);
+  const skip = {
+    enoent: Number(collected?.enoent) || 0,
+    cap: Number(collected?.cap) || 0,
+    dir: Number(collected?.dir) || 0,
+    rel: Number(collected?.rel) || 0,
+  };
+  const bash = Number(collected?.bash) || 0;
+  const chunks = [];
+  const readSeen = new Set();
+
+  const readOne = (abs) => {
+    if (!abs || readSeen.has(abs)) return;
+    readSeen.add(abs);
+    try {
+      chunks.push(`FILE ${abs}\n${readFileSync(abs)}`);
+    } catch {
+      skip.enoent += 1;
+    }
+  };
+
+  const bindChild = (abs) => {
+    let st;
+    try { st = statSync(abs); } catch { skip.enoent += 1; return; }
+    if (!st.isFile()) return;
+    if (st.size > cap) { skip.cap += 1; return; }
+    const key = `${abs}:${st.mtimeMs}`;
+    if (boundFiles?.has(key)) return;
+    boundFiles?.add(key);
+    readOne(abs);
+  };
+
+  for (const item of pending) {
+    const abs = typeof item === 'string' ? item : item?.abs;
+    if (!abs) continue;
+    if (item?.kind === 'dir') {
+      let kids = [];
+      try { kids = readdirSync(abs); } catch { skip.enoent += 1; continue; }
+      for (const name of kids) {
+        if (!name || name.startsWith('.') || SKIP_DIR_NAMES.has(name)) continue;
+        bindChild(path.join(abs, name));
+      }
+      continue;
+    }
+    readOne(abs);
   }
 
   const text = chunks.join('\n\n');
@@ -353,12 +451,165 @@ export function filesForCorpus(msgs, {
     cap: skip.cap,
     dir: skip.dir,
     rel: skip.rel,
-    bash: bash.length,
+    bash,
   };
   log(fileBindLog(stats));
   return { text, files: chunks.length, bytes: text.length, reason: chunks.length ? null : 'none-kept', ...stats };
 }
 
+/**
+ * path:mtime keys -> absolute paths. mtime is always the last `:Number` segment
+ * so `C:\foo:1734.2` still splits correctly.
+ */
+export function boundAbsFromKeys(boundFiles) {
+  const out = new Set();
+  if (!boundFiles) return out;
+  for (const key of boundFiles) {
+    if (typeof key !== 'string' || !key) continue;
+    const i = key.lastIndexOf(':');
+    if (i <= 0) { out.add(key); continue; }
+    const rest = key.slice(i + 1);
+    if (rest !== '' && Number.isFinite(Number(rest))) out.add(key.slice(0, i));
+    else out.add(key);
+  }
+  return out;
+}
+
+const FILE_VIEW = /^(head|tail|cat|less|more|type|Get-Content|gc)\b/i;
+
+/** `head -80 notes.md` and `cd dir && cat x` count; `npm test` and `cat x | rg y` do not. */
+export function looksLikeFileView(command) {
+  if (typeof command !== 'string' || !command.trim()) return false;
+  let sawView = false;
+  for (const part of command.split(/(?:&&|\|\||;|\n)/)) {
+    const t = part.trim();
+    if (!t) continue;
+    if (/^cd\s+/.test(t)) continue;
+    if (/\|/.test(t)) return false;
+    if (FILE_VIEW.test(t)) { sawView = true; continue; }
+    return false;
+  }
+  return sawView;
+}
+
+export function fileBoundStub(paths) {
+  const list = [...new Set((paths || []).filter(Boolean))].join(' ');
+  return list ? `FILE ${list} [bound]` : 'FILE [bound]';
+}
+
+function toolContentLength(content) {
+  if (typeof content === 'string') return content.length;
+  if (Array.isArray(content)) {
+    return content.reduce((n, b) => n + (typeof b === 'string' ? b.length : String(b?.text ?? b?.content ?? '').length), 0);
+  }
+  if (content && typeof content === 'object') return JSON.stringify(content).length;
+  return 0;
+}
+
+function resolveBoundPath(raw, cwd, boundAbs) {
+  if (!boundAbs?.size) return null;
+  const t = typeof raw === 'string' ? raw.trim() : '';
+  if (!t) return null;
+  const abs = resolveReadablePath(t, cwd);
+  if (abs && boundAbs.has(abs)) return abs;
+  if (boundAbs.has(t)) return t;
+  return null;
+}
+
+/**
+ * After a file is bound, drop its tool_result / file body from the forwarded
+ * tail. Keep the path and a short marker. The model already has the bytes in
+ * the bound corpus via recall; shipping them again makes sent ≈ corpus and
+ * the gateway's `counterfactualTokens > promptTokens` gate barely fires
+ * (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.
+ *
+ * `fromIndex` limits the rewrite to the forwarded tail so the spilled prefix
+ * that becomes the conversation corpus is unchanged.
+ */
+export function stubBoundFileResults(msgs, {
+  boundFiles,
+  boundAbs,
+  cwd = process.cwd(),
+  fromIndex = 0,
+} = {}) {
+  const absSet = boundAbs || boundAbsFromKeys(boundFiles);
+  if (!Array.isArray(msgs) || !absSet.size) {
+    return { messages: msgs, stubbed: 0, dropped: 0 };
+  }
+
+  const stubIds = new Set();
+  const idPaths = new Map();
+  let currentCwd = cwd;
+
+  const noteCall = (c) => {
+    const id = c?.id || c?.tool_call_id;
+    const args = parseArgs(c?.function?.arguments ?? c?.arguments);
+    const raws = [];
+    collectStructuredPaths(args, raws);
+    if (typeof args.command === 'string' && looksLikeFileView(args.command)) {
+      for (const p of extractBashPaths(args.command, currentCwd).paths) raws.push(p.raw);
+    }
+    const resolved = [];
+    for (const raw of raws) {
+      const hit = resolveBoundPath(raw, currentCwd, absSet);
+      if (hit) resolved.push(hit);
+    }
+    if (!resolved.length || !id) return;
+    stubIds.add(id);
+    idPaths.set(id, [...(idPaths.get(id) || []), ...resolved]);
+  };
+
+  for (const m of msgs) {
+    if (!m || typeof m !== 'object') continue;
+    if (m.role === 'tool' && typeof m.content === 'string') {
+      const hint = parseCwdHint(m.content);
+      if (hint) currentCwd = hint;
+    }
+    const calls = [
+      ...(Array.isArray(m.tool_calls) ? m.tool_calls : []),
+      ...(m.function_call ? [m.function_call] : []),
+    ];
+    for (const c of calls) noteCall(c);
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (b?.type === 'tool_use') {
+        noteCall({ id: b.id, arguments: b.input, function: { name: b.name, arguments: b.input } });
+      }
+    }
+  }
+
+  if (!stubIds.size) return { messages: msgs, stubbed: 0, dropped: 0 };
+
+  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)) {
+      const n = toolContentLength(m.content);
+      if (!n) return m;
+      dropped += n;
+      stubbed += 1;
+      return { ...m, content: fileBoundStub(idPaths.get(m.tool_call_id)) };
+    }
+    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;
+      const n = toolContentLength(b.content);
+      if (!n) return b;
+      dropped += n;
+      stubbed += 1;
+      changed = true;
+      return { ...b, content: fileBoundStub(idPaths.get(b.tool_use_id)) };
+    });
+    return changed ? { ...m, content: blocks } : m;
+  });
+  return { messages, stubbed, dropped };
+}
+
 /** Session counters the HUD reads off /v1/info. */
 export function createSpillStats() {
   return {

package/package.json

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