openzoo 0.48.57 → 0.48.59

package/lib/proxy.js

@@ -1,6 +1,7 @@
 import { readFileSync, appendFileSync, mkdirSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import fs from 'node:fs';
 import http from 'node:http';
 import crypto from 'node:crypto';
 import { Readable } from 'node:stream';
@@ -115,6 +116,9 @@ const mb = (n) => (n / 1048576).toFixed(1);
 
 // anchor -> { corpus, contextId, hash } for append-only transcript spills
 const spillMemo = new Map();
+// path:mtime of every file already bound — a file is bound once per version,
+// never re-uploaded because the agent read it again.
+const boundFiles = new Set();
 
 /**
  * Every fundable balance across all three chains, for the startup line and
@@ -411,10 +415,31 @@ async function spillTranscript(body, log, req) {
   // 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);
-  if (msgs.length - cut < minTurns) {
-    for (let i = Math.max(firstSpillable + 1, msgs.length - minTurns); i > firstSpillable; i--) {
-      if (severable(i)) { cut = i; break; }
+  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; }
     }
   }
 
@@ -442,7 +467,61 @@ async function spillTranscript(body, log, req) {
   if (lastUser > firstSpillable && cut > lastUser) cut = lastUser;
 
   const head = msgs.slice(0, firstSpillable);     // system block, always kept
-  const corpus = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
+  // EVERY FILE THE AGENT TOUCHED, AT FULL SIZE.
+  //
+  // The saving ratio is corpus/sent, so on a fresh session — where the corpus
+  // IS the conversation — it starts near 1x and only climbs as you talk. That
+  // is exactly what the live agent numbers showed: 1.0-1.3x early, 8x once a
+  // 149k-token history existed. MEASURED the same day: prompt compressed 2.67x
+  // but billed savings was 1.13x, because output does not compress and a small
+  // corpus leaves nothing to compress on the other side either.
+  //
+  // Files are the fix. An agent reads far more bytes than it discusses, the
+  // harness has usually TRUNCATED them on the way in, and the full text is
+  // 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, and failures are silent: this
+  // runs on the request path and must never be the reason a turn does not go.
+  const filesForCorpus = () => {
+    if (process.env.OPENZOO_BIND_FILES === '0') return '';
+    const cap = Number(process.env.OPENZOO_BIND_FILE_MAX || 400_000);
+    const out = [];
+    const seen = new Set();
+    for (const m of msgs) {
+      const blocks = Array.isArray(m?.content) ? m.content : [];
+      const calls = Array.isArray(m?.tool_calls) ? m.tool_calls : [];
+      const paths = [];
+      for (const b of blocks) {
+        const p = b?.input?.file_path || b?.input?.path;
+        if (typeof p === 'string') paths.push(p);
+      }
+      for (const c of calls) {
+        try {
+          const a = JSON.parse(c?.function?.arguments || '{}');
+          if (typeof a.file_path === 'string') paths.push(a.file_path);
+          else if (typeof a.path === 'string') paths.push(a.path);
+        } catch { /* not json args */ }
+      }
+      for (const p of paths) {
+        if (seen.has(p) || !path.isAbsolute(p)) continue;
+        seen.add(p);
+        try {
+          const st = fs.statSync(p);
+          if (!st.isFile() || st.size > cap) continue;
+          const key = `${p}:${st.mtimeMs}`;
+          if (boundFiles.has(key)) continue;
+          boundFiles.add(key);
+          out.push(`FILE ${p}\n${fs.readFileSync(p, 'utf8')}`);
+        } catch { /* unreadable, gone, or binary — simply not corpus */ }
+      }
+    }
+    return out.join('\n\n');
+  };
+
+  const turns = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
+  const files = filesForCorpus();
+  const corpus = files ? `${turns}\n\n${files}` : turns;
   if (corpus.length <= BIND_MIN_CHARS) return null;
 
   // CONTINUE THE CONTEXT, BIND ONLY THE DELTA.

package/package.json

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