openzoo 0.48.63 → 0.48.64

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

@@ -1216,7 +1216,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 +1262,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 */ }
     }

package/package.json

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