openzoo 0.48.30 → 0.48.32

package/lib/proxy.js

@@ -331,8 +331,29 @@ async function spillTranscript(body, log) {
     ? `transcript prefix already bound (${bind.contextId}) — sending ${sent}/${msgs.length} turns`
     : `transcript prefix bound (${mb(bind.bytes)}MB → ${bind.contextId}) — sending ${sent}/${msgs.length} turns`);
 
+  // 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,
+  // same corpus, nearly double the saving. Recall breadth, not markup, is the
+  // lever, and spilling 34k tokens only to recall 22k of them back is not a
+  // saving, it is a round trip.
+  //
+  // So budget the recall in TOKENS and derive k from it, rather than fixing the
+  // chunk count and letting the token cost fall where it may. ~320 tokens per
+  // chunk measured. The budget scales with the ask — a one-line question needs
+  // 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;
+  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)),
+  );
+  const topK = Math.max(4, Math.min(32, Math.round(budget / 320)));
+
   return {
     body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),
+    topK,
     contextId: bind.contextId,
     hash: bind.hash,
     corpus,
@@ -767,6 +788,40 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       try {
         const parsed = JSON.parse(bodyBuf.toString('utf8'));
         wantsStream = parsed?.stream === true;
+        // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
+        //
+        // The budget covers hidden reasoning AND the visible answer, so a
+        // caller that asks for 40 tokens because it wants a short answer often
+        // gets ZERO — the whole allowance went to reasoning and the completion
+        // truncated to an empty string. Measured across three families in one
+        // day: deepseek returned 0 chars at 8k and was fine at 24k; grok-4.6
+        // pinned ct at exactly its 16,000 budget with no visible output;
+        // sonnet-5 truncated a 600-token file mid-function because Anthropic's
+        // max_tokens covers thinking too.
+        //
+        // An empty completion is not an error — it bills normally and renders
+        // as a blank reply — so this fails silently and looks like the retrieval
+        // broke. It cost real debugging time tonight for exactly that reason.
+        // Multiply the allowance for known reasoning families and let callers
+        // keep asking for what they actually want back.
+        const REASONING = /(deepseek|grok|o[134](-|$)|reasoner|thinking|-pro\b|sol-pro|qwq)/i;
+        const mult = Number(process.env.OPENZOO_REASONING_MAX_TOKENS_X || 4);
+        const cap = Number(process.env.OPENZOO_REASONING_MAX_TOKENS_CAP || 32000);
+        const mdl = String(parsed?.model || '');
+        const mt = Number(parsed?.max_tokens);
+        // A MULTIPLIER ALONE IS NOT ENOUGH. 4x on a caller's 40 is 160, which is
+        // still nothing for a model that thinks first — measured, 2 of 3 runs
+        // still returned empty at 160. Reasoning needs an absolute floor, not a
+        // relative bump, so take whichever is larger.
+        const floor = Number(process.env.OPENZOO_REASONING_MIN_TOKENS || 4000);
+        if (mult > 1 && REASONING.test(mdl) && Number.isFinite(mt) && mt > 0 && mt < cap) {
+          const raised = Math.min(cap, Math.max(floor, Math.round(mt * mult)));
+          if (raised > mt) {
+            parsed.max_tokens = raised;
+            bodyBuf = Buffer.from(JSON.stringify(parsed));
+            log(`reasoning model ${mdl}: max_tokens ${mt} -> ${raised} (thinking shares the budget; OPENZOO_REASONING_MAX_TOKENS_X=1 disables)`);
+          }
+        }
         // Tell the agent what it is actually connected to — in band, where it
         // will read it, instead of leaving it to guess (and to chunk corpora
         // it could bind whole). See lib/brief.js.
@@ -842,17 +897,24 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       } catch (err) {
         log(`context cache skipped for this call: ${err.message}`);
       }
-      const send = (buf, ctxId) => client.fetch(url, {
+      const send = (buf, ctxId, topK) => client.fetch(url, {
         ...init,
         body: buf,
-        headers: ctxId ? { ...init.headers, 'x-hrr-context': ctxId } : init.headers,
+        headers: ctxId
+          ? {
+            ...init.headers,
+            'x-hrr-context': ctxId,
+            // Only on the spill path — a caller that set its own top-k keeps it.
+            ...(topK ? { 'x-hrr-top-k': String(topK) } : {}),
+          }
+          : init.headers,
       });
       let result;
       if (cached) {
         spillCalls += 1;
         spilledChars += cached.corpus?.length || 0;
         if (cached.reused) spillReuses += 1;
-        result = await send(cached.body, cached.contextId);
+        result = await send(cached.body, cached.contextId, cached.topK);
         // 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) {
@@ -861,7 +923,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);
+            result = await send(cached.body, rebound.contextId, cached.topK);
           } else {
             res.writeHead(404, { 'content-type': 'application/json' });
             res.end(text);

package/package.json

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