openzoo 0.48.63 → 0.48.65

package/lib/brief.js

@@ -19,24 +19,22 @@
  * not an API) because nothing in the conversation named the real one.
  */
 export const briefFor = (selfUrl) => [
-  'Environment notes for this endpoint (descriptive — verify anything you rely on):',
-  '',
-  ...(selfUrl ? [
-    `- Base URL: ${selfUrl}. It already ends in /v1, so routes are ${selfUrl}/chat/completions, ${selfUrl}/hrr/bind, ${selfUrl}/models. A doubled /v1 is repaired by the proxy but logs a warning. openzoo.fun is a website, not an API host.`,
-    '',
-  ] : []),
-  '- Long bodies: requests over ~16KB are carved and bound to a holographic (HRR) memory before the model sees them, and the model answers from retrieval over that. So a large corpus can be sent whole; summarising or chunking it to fit is not required here, though nothing stops you. `context_length` in /v1/models reports the client-usable ceiling (128M tokens); the transformer window is `max_model_len`. A single POST over ~9.8M tokens (~32MiB) is rejected by the edge.',
-  '',
-  '- Repeat sends: a corpus placed first, followed by a blank line and then a question, binds once. Later questions reusing it ship only the question, which is cheaper and faster. Re-sending the same corpus each turn costs full price each time.',
-  '',
-  '  Explicit bind (unpaid): POST /v1/hrr/bind with {"corpus": "..."} returns {"context_id": "..."}. Passing that id as the X-HRR-Context header on later /v1/chat/completions calls lets the body stay small. Passing an existing context_id alongside a new corpus appends to it, which is how a corpus larger than one request gets bound in parts.',
-  '  Request size: single requests over ~8MB are dropped by the network hop before reaching the proxy (opaque 413 or dead connection). That is a request limit, not a context limit.',
-  '',
-  '- Payment: calls are settled per request from the operator\'s own wallet via x402 (Solana / Base / Robinhood Chain, whichever is funded). There is no account to create and no key for you to supply or handle. GET / on this proxy returns the same description. /hrr/bind and GET /models are unpaid; /chat/completions is paid and uses the bearer key the client is already configured with, which is not readable from inside the conversation.',
-  '',
-  '- Model ids: unknown ids are matched to the nearest served model rather than erroring. /v1/models lists what is actually served, and each alias row carries `served_by`.',
+  // SMALL ON PURPOSE. This used to be ~2.2KB of prose on EVERY request —
+  // corpus binding, request-size limits, payment rails, model-id matching —
+  // most of which a given call never needs, all of which the caller pays for in
+  // tokens and latency. An agent that needs the detail can ask; what it cannot
+  // work out for itself is the base URL and the one behaviour that changes how
+  // it should send a big body. Everything else was documentation shipped as
+  // overhead.
+  ...(selfUrl ? [`Endpoint: ${selfUrl} (already ends in /v1). Routes: /chat/completions, /hrr/bind, /models.`] : []),
+  'Bodies over ~16KB are bound to holographic memory and answered by retrieval, so a large corpus can be sent whole rather than summarised or chunked. A corpus sent once is not re-uploaded.',
+  'Calls are paid per request from the operator\'s wallet; there is no key to supply. Unknown model ids match the nearest served model.',
 ].join('\n');
 
+/** Stable substring used to detect an already-injected brief. Must appear in
+ *  briefFor() output verbatim — see injectBrief(). */
+export const BRIEF_MARK = 'bound to holographic memory and answered by retrieval';
+
 /** Back-compat: the briefing with no endpoint line. */
 export const BRIEF = briefFor(null);
 
@@ -51,7 +49,11 @@ export function injectBrief(body, selfUrl = null) {
   if (process.env.OPENZOO_NO_BRIEF === '1') return null;
   const msgs = body?.messages;
   if (!Array.isArray(msgs) || !msgs.length) return null;
-  if (msgs.some((m) => typeof m?.content === 'string' && m.content.includes('connected through an openzoo proxy'))) return null;
+  // THE SENTINEL MUST BE TEXT THE BRIEF ACTUALLY CONTAINS. This checked for
+  // 'connected through an openzoo proxy' — the old opening line — so shrinking
+  // the brief would have silently broken idempotency and stacked a fresh copy
+  // onto every single turn, growing the system block without bound.
+  if (msgs.some((m) => typeof m?.content === 'string' && m.content.includes(BRIEF_MARK))) return null;
 
   const brief = { role: 'system', content: briefFor(selfUrl) };
   // THE LEADING SYSTEM RUN ONLY — NOT THE LAST SYSTEM ANYWHERE.

package/lib/proxy.js

@@ -123,6 +123,51 @@ const boundFiles = new Set();
 // basis must reflect what the corpus actually holds, not just this turn's slice.
 const boundChars = new Map();
 
+// THIS MAP SURVIVES A RESTART, OR THE COUNTERFACTUAL DOES NOT.
+//
+// boundChars is the only record of how large a bound corpus has GROWN. It feeds
+// `x-hrr-corpus-chars`, which is what lets the gateway price the counterfactual
+// against the whole corpus instead of against the turn in front of it. Held
+// purely in memory, every restart silently reset that basis to the live body and
+// savings fell to exactly 1.00x until a session re-accumulated — with nothing in
+// the log to say why, because the corpus in the DAEMON was still there. Only our
+// accounting of it was gone.
+//
+// MEASURED minutes after a restart: `basis 16112 tok vs sent 16112 -> 4238 ·
+// billed 1.14063 direct 1.14063`. The body spilled 3.8x and the bill did not
+// move, because basis fell back to `cached.corpus?.length`.
+//
+// Advisory, never load-bearing: a corrupt or missing file just means we start
+// counting again, which is exactly today's behaviour.
+const BOUND_CHARS_FILE = path.join(os.homedir(), '.openzoo', 'bound-chars.json');
+const BOUND_CHARS_MAX = 500; // newest contexts only; this is a ledger, not a log
+
+let boundCharsRestored = 0;
+try {
+  const saved = JSON.parse(fs.readFileSync(BOUND_CHARS_FILE, 'utf8'));
+  for (const [ctx, chars] of Object.entries(saved)) {
+    if (typeof chars === 'number' && chars > 0) boundChars.set(ctx, chars);
+  }
+  boundCharsRestored = boundChars.size;
+} catch { /* absent or unreadable — start empty, same as before */ }
+
+let boundCharsTimer = null;
+/** Debounced: appends land in bursts, and the basis only has to survive a
+ *  restart, not every keystroke. Never rejects — persistence is a nicety. */
+const persistBoundChars = () => {
+  if (boundCharsTimer) return;
+  boundCharsTimer = setTimeout(() => {
+    boundCharsTimer = null;
+    try {
+      // Map preserves insertion order, so the tail is the newest.
+      const entries = [...boundChars.entries()].slice(-BOUND_CHARS_MAX);
+      mkdirSync(path.dirname(BOUND_CHARS_FILE), { recursive: true });
+      fs.writeFileSync(BOUND_CHARS_FILE, JSON.stringify(Object.fromEntries(entries)));
+    } catch { /* advisory */ }
+  }, 2000);
+  boundCharsTimer.unref?.(); // must never hold the process open
+};
+
 /**
  * Every fundable balance across all three chains, for the startup line and
  * the live refresh. Each read is independent and advisory — one lagging RPC
@@ -567,6 +612,7 @@ async function spillTranscript(body, log, req) {
       }).then((b) => {
         if (!b?.contextId) return;
         boundChars.set(b.contextId, (boundChars.get(b.contextId) || 0) + files.length);
+        persistBoundChars();
         if (!known) spillMemo.set(sessionKey, { corpus, contextId: b.contextId, hash: b.hash });
       }).catch((e) => log(`file bind failed: ${e.message}`));
     }
@@ -639,6 +685,7 @@ async function spillTranscript(body, log, req) {
   // 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);
+    persistBoundChars();
     void bindCorpus(files, {
       appendTo: bind.contextId,
       onStage: (stage, info) => {
@@ -1216,7 +1263,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         bodyBuf = rw.body;
       }
       try {
-        const parsed = JSON.parse(bodyBuf.toString('utf8'));
+        let parsed = JSON.parse(bodyBuf.toString('utf8'));
         wantsStream = parsed?.stream === true || clientWantsStream;
         // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
         //
@@ -1262,8 +1309,56 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           const selfUrl = viaTunnel && tunnelGate?.publicUrl
             ? `${tunnelGate.publicUrl}/v1`
             : `http://localhost:${config.port}/v1`;
-          const briefed = injectBrief(parsed, selfUrl);
-          if (briefed) bodyBuf = Buffer.from(JSON.stringify(briefed));
+          // NOT ON A YES/NO. The brief is ~2.2KB describing corpus binding,
+          // request-size limits and payment — none of which a tiny call can
+          // use. Claude Code's auto-mode safety classifier asks a 16-token
+          // question before it will run Bash, and it has a short timeout:
+          // MEASURED, that call takes 3.5s cold through here against a 0.09s
+          // gateway 402, and it times out on a machine paying on-chain. Adding
+          // 2.2KB of prose to a body that small is latency and tokens spent on
+          // advice nobody will read.
+          //
+          // Threshold is the same one the spill uses: below it there is no
+          // corpus and nothing the brief could help with.
+          const tiny = bodyBuf.length < BIND_MIN_CHARS
+            && Number(parsed?.max_tokens ?? 0) > 0
+            && Number(parsed?.max_tokens) <= 64;
+          const briefed = tiny ? null : injectBrief(parsed, selfUrl);
+          if (briefed) parsed = briefed;
+          // SYSTEM MESSAGES BELONG AT THE FRONT, OR GOOGLE 400s.
+          //
+          // Claude Code emits <system-reminder> blocks mid-conversation, which
+          // is legal for Anthropic natively. Several upstreams behind OpenRouter
+          // are not: fable-5 is served by GOOGLE, whose API takes a system
+          // instruction only before the conversation starts and rejects one
+          // after. CAPTURED live — provider_error code 400,
+          // roles="sssusatatus", 311KB body: two system messages sitting after
+          // user turns, on a model that answers a simple call fine.
+          //
+          // So fold every later system message into the leading block, in
+          // order. The content survives and its position moves; the alternative
+          // is a 400 that ends the turn and tells the caller nothing.
+          const nm = Array.isArray(parsed?.messages) ? parsed.messages : null;
+          if (nm && nm.length > 1) {
+            let lead = 0;
+            while (lead < nm.length && nm[lead]?.role === 'system') lead += 1;
+            const strays = [];
+            const kept = [];
+            nm.forEach((m, i) => {
+              if (i >= lead && m?.role === 'system') strays.push(m);
+              else kept.push(m);
+            });
+            if (strays.length) {
+              const merged = strays.map((m) => (typeof m.content === 'string' ? m.content : msgText(m))).filter(Boolean).join('\n\n');
+              const head = kept.slice(0, lead);
+              const tailMsgs = kept.slice(lead);
+              if (head.length) head[head.length - 1] = { ...head[head.length - 1], content: `${typeof head[head.length - 1].content === 'string' ? head[head.length - 1].content : msgText(head[head.length - 1])}\n\n${merged}` };
+              else head.push({ role: 'system', content: merged });
+              parsed = { ...parsed, messages: [...head, ...tailMsgs] };
+              log(`hoisted ${strays.length} interleaved system message(s) to the leading block (some providers 400 otherwise)`);
+            }
+          }
+          bodyBuf = Buffer.from(JSON.stringify(parsed));
         }
       } catch { /* not JSON */ }
     }
@@ -1805,6 +1900,10 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         process.once('SIGTERM', () => { bye(); process.exit(0); });
         process.once('exit', bye);
         log('');
+        if (boundCharsRestored) {
+          const tot = [...boundChars.values()].reduce((a, b) => a + b, 0);
+          log(`corpus ledger restored: ${boundCharsRestored} context(s), ${mb(tot)}MB bound — counterfactual survives restarts`);
+        }
         log('cloud IDE / remote harness? use the public URL (they cannot reach localhost):');
         log(`  base_url = ${url}/v1`);
         log(`  api_key  = ${token}`);

package/package.json

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