openzoo 0.48.61 → 0.48.63

package/lib/proxy.js

@@ -119,6 +119,9 @@ 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();
+// context_id -> total chars BOUND (turns + files appended). The counterfactual
+// basis must reflect what the corpus actually holds, not just this turn's slice.
+const boundChars = new Map();
 
 /**
  * Every fundable balance across all three chains, for the startup line and
@@ -519,10 +522,56 @@ async function spillTranscript(body, log, req) {
     return out.join('\n\n');
   };
 
+  // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
+  //
+  // The FIRST bind of a session is necessarily synchronous — the request cannot
+  // go until the context_id exists, because it travels as x-hrr-context. Folding
+  // file bytes into that bind put a 400KB upload in front of the caller's turn,
+  // which is the cold-bind stall this whole exercise was meant to remove: the
+  // bind endpoint measures 0.34-0.48s on a 613KB corpus, and that is 0.34-0.48s
+  // the user waits before a single token appears.
+  //
+  // Nothing recalls a file during the turn that read it — the model already has
+  // the tool result in its window. Files are only worth having bound for the
+  // NEXT ask. So the conversation binds inline and the files are appended after
+  // the fact, off the clock.
   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;
+  const corpus = turns;
+
+  // FILES BIND EVEN WHEN THE CONVERSATION IS TOO SMALL TO SPILL.
+  //
+  // The threshold exists to stop us binding a two-line chat — it was never
+  // meant to gate FILES. But bailing here skipped them entirely, so a fresh
+  // session that reads a 200KB file bound nothing and scored 1.00x forever:
+  // OBSERVED on a live session that read files all turn and never produced a
+  // corpus, because its conversation stayed under the threshold the whole time.
+  //
+  // A file is worth binding on its own merit. So when the turns are too small
+  // to spill but files exist, bind the files anyway — in the background,
+  // against this session's context — and let this turn go unspilled. The corpus
+  // is then waiting for the next ask.
+  const sessionId = req?.headers?.['x-claude-code-session-id']
+    || req?.headers?.['x-session-id']
+    || req?.headers?.['x-claude-session-id']
+    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
+  const sessionKey = sessionId ? `sid:${sessionId}` : corpus.slice(0, 2048);
+  if (corpus.length <= BIND_MIN_CHARS) {
+    if (files) {
+      const known = spillMemo.get(sessionKey);
+      void bindCorpus(files, {
+        appendTo: known?.contextId || null,
+        onStage: (stage, info) => {
+          if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of FILES (conversation under spill threshold, background)`);
+        },
+      }).then((b) => {
+        if (!b?.contextId) return;
+        boundChars.set(b.contextId, (boundChars.get(b.contextId) || 0) + files.length);
+        if (!known) spillMemo.set(sessionKey, { corpus, contextId: b.contextId, hash: b.hash });
+      }).catch((e) => log(`file bind failed: ${e.message}`));
+    }
+    return null;
+  }
 
   // CONTINUE THE CONTEXT, BIND ONLY THE DELTA.
   //
@@ -554,11 +603,7 @@ async function spillTranscript(body, log, req) {
   // The real header list is:
   //   anthropic-beta, anthropic-version, x-app, x-claude-code-session-id,
   //   x-stainless-*
-  const sessionId = req?.headers?.['x-claude-code-session-id']
-    || req?.headers?.['x-session-id']
-    || req?.headers?.['x-claude-session-id']
-    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
-  const anchor = sessionId ? `sid:${sessionId}` : corpus.slice(0, 2048);
+  const anchor = sessionKey;
   const prior = spillMemo.get(anchor);
   let bind;
   if (prior && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
@@ -588,6 +633,19 @@ async function spillTranscript(body, log, req) {
       },
     });
   }
+  // 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) {
+    boundChars.set(bind.contextId, (boundChars.get(bind.contextId) || corpus.length) + files.length);
+    void bindCorpus(files, {
+      appendTo: bind.contextId,
+      onStage: (stage, info) => {
+        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB of FILES to ${bind.contextId} (background)`);
+      },
+    }).catch((e) => log(`file append failed (corpus lags one turn): ${e.message}`));
+  }
   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;
@@ -771,6 +829,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // cost can.
   let sessionActual = 0;
   let actualCalls = 0;
+  // billed for ONLY those calls whose real cost we learned — the honest
+  // numerator for markupX. See the comment at the usage.cost site.
+  let billedWithActual = 0;
   // CREDIT, CACHED. Users cannot tell prepaid credit from wallet balance and
   // have to guess whether a call was even paid for ("I don't think x402 made me
   // pay this at all"). The status line runs EVERY turn, so this is refreshed at
@@ -922,9 +983,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           actual: {
             calls: actualCalls,
             upstreamUsd: Number(sessionActual.toFixed(6)),
-            billedUsd: Number(sessionSpent.toFixed(6)),
-            marginUsd: Number((sessionSpent - sessionActual).toFixed(6)),
-            markupX: sessionActual > 0 ? Number((sessionSpent / sessionActual).toFixed(2)) : null,
+            billedUsd: Number(billedWithActual.toFixed(6)),
+            marginUsd: Number((billedWithActual - sessionActual).toFixed(6)),
+            markupX: sessionActual > 0 ? Number((billedWithActual / sessionActual).toFixed(2)) : null,
           },
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
@@ -1210,6 +1271,21 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // Retry of a body we answered seconds ago? Serve the cached completion —
     // never pay twice for a harness's reconnect loop.
     const isChat = req.method === 'POST' && (req.url || '').includes('/chat/completions');
+    // GROUND TRUTH ON THE OUTGOING BODY. Three sessions have now reported "no
+    // actual question or task from you" while the proxy log showed a healthy
+    // forward, and two rounds of reasoning about the cut were wrong. Log what
+    // is actually in messages[] on the way out — roles, and the tail of the
+    // last user turn — so the question stops being a matter of opinion.
+    if (process.env.OPENZOO_LOG_BODY === '1' && isChat) {
+      try {
+        const b = JSON.parse(bodyBuf.toString('utf8'));
+        const ms = Array.isArray(b?.messages) ? b.messages : [];
+        const roles = ms.map((m) => (m.role || '?')[0]).join('');
+        const lastUser = [...ms].reverse().find((m) => m.role === 'user');
+        const txt = lastUser ? String(msgText(lastUser)).slice(-160).replace(/\s+/g, ' ') : '(NO USER MESSAGE)';
+        log(`  OUT roles=${roles} n=${ms.length} lastUser="${txt}"`);
+      } catch { /* not json */ }
+    }
     const rKey = isChat ? replayKey(bodyBuf, req.headers) : null;
     if (rKey) {
       const hit = replayGet(rKey);
@@ -1295,7 +1371,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         didSpill = true;
         spilledChars += cached.corpus?.length || 0;
         if (cached.reused) spillReuses += 1;
-        result = await send(cached.body, cached.contextId, cached.topK, cached.corpus?.length);
+        result = await send(cached.body, cached.contextId, cached.topK, boundChars.get(cached.contextId) || cached.corpus?.length);
         // Sidecar wiped between runs: the gateway 404s BEFORE the 402 (nothing
         // paid). Never fail on a stale manifest — re-bind once and retry.
         if (result.response.status === 404) {
@@ -1304,7 +1380,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             log('bound context is gone on the zoo — re-binding once...');
             forgetContext(config.apiBase, cached.hash);
             const rebound = await bindCorpus(cached.corpus, { force: true });
-            result = await send(cached.body, rebound.contextId, cached.topK, cached.corpus?.length);
+            result = await send(cached.body, rebound.contextId, cached.topK, boundChars.get(rebound.contextId) || cached.corpus?.length);
           } else {
             res.writeHead(404, { 'content-type': 'application/json' });
             res.end(text);
@@ -1378,6 +1454,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (typeof data?.usage?.cost === 'number' && data.usage.cost >= 0) {
           sessionActual += data.usage.cost;
           actualCalls += 1;
+          // PAIR THE NUMERATOR WITH THE DENOMINATOR. sessionSpent is summed on
+          // three paths and sessionActual on two, so markupX divided ALL billed
+          // by the SUBSET that reported a real cost — a 402-receipt call added
+          // to billed and nothing to real, and the ratio read 12.55x on a stack
+          // running at ~1.0x. Track the billed side of exactly the calls whose
+          // cost we actually learned.
+          // Both figures ride the SAME response object, so read them together
+          // rather than carrying one across sites and hoping the order holds.
+          billedWithActual += Number(data?.x402?.billedUsd) || 0;
         }
         // PREPAID CALLS STILL COST MONEY. The block above only meters calls
         // where THIS proxy answered a 402 and paid. When prepaid credit covers
@@ -1455,7 +1540,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         sessionSpent += x.billedUsd;
         sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
         sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
-        if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; }
+        if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; billedWithActual += x.billedUsd || 0; }
         if (didSpill) {
           const lc = x.lecore || {};
           log(`spill priced (streamed): ${x.pricing} · basis ${x.counterfactualTokensUsed ?? '?'} tok vs sent ${lc.tokensBefore ?? '?'} -> ${lc.tokensAfter ?? '?'} · billed ${(x.billedUsd ?? 0).toFixed(5)} direct ${(x.directUsd ?? 0).toFixed(5)}`);

package/package.json

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