openzoo 0.48.62 → 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

@@ -829,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
@@ -980,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,
@@ -1213,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.
         //
@@ -1259,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 */ }
     }
@@ -1268,6 +1319,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);
@@ -1436,6 +1502,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
@@ -1513,7 +1588,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.62",
+  "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",