openzoo 0.51.23 → 0.51.26

package/lib/proxy.js

@@ -27,16 +27,27 @@ import { detectModelCommand, applyModelCommand, serveModelCommand, readOverride
  * Free read, but harnesses probe on every /model keystroke confirmation —
  * without a cache each probe is an upstream round trip.
  */
-let catalogIdsMemo = { at: 0, ids: [] };
+let catalogIdsMemo = { at: 0, ids: [], house: new Set() };
 async function catalogIdsCached(modelsUrl, headers) {
   if (Date.now() - catalogIdsMemo.at < 5 * 60_000 && catalogIdsMemo.ids.length) return catalogIdsMemo.ids;
   const r = await fetch(modelsUrl, { headers, signal: AbortSignal.timeout(8000) });
   if (!r.ok) throw new Error(`catalog ${r.status}`);
   const payload = await r.json();
-  const ids = quoteableRows(payload?.data).map((m) => m.id);
-  if (ids.length) catalogIdsMemo = { at: Date.now(), ids };
+  const rows = quoteableRows(payload?.data);
+  const ids = rows.map((m) => m.id);
+  // House doors (`owned_by: "openzoo"` — abliterated-model*, openzoo/auto)
+  // take plain `function` tools only; see responsestools.js.
+  const house = new Set(rows.filter((m) => m.owned_by === 'openzoo').map((m) => m.id));
+  if (ids.length) catalogIdsMemo = { at: Date.now(), ids, house };
   return ids;
 }
+/** Models we have SEEN reject Responses tool groups with `invalid_tools`,
+ *  so the next request flattens before paying instead of after. */
+const flattenLearned = new Set();
+function wantsFlatTools(model) {
+  const id = String(model || '');
+  return flattenLearned.has(id) || catalogIdsMemo.house.has(id) || /^abliterated-model/.test(id);
+}
 import { withNamespace } from './namespace.js';
 import { loadSessionSpend, saveSessionSpend, sessionSpendFile } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
@@ -44,6 +55,7 @@ import { priceHoldings } from './livestatus.js';
 import { receiptUsedCogs, receiptDirectUsd, pairActualBilled } from './racesettle.js';
 import { fetchHeaders } from './fetch.js';
 import { attachX402Proof } from './spendProof.js';
+import { flattenResponsesTools, restoreResponsesPayload, sseNamespaceRestorer, isInvalidToolsError } from './responsestools.js';
 
 /** Kill whatever is LISTEN on this port except this process.
  *  lsof first (macOS), then fuser, then /proc (Omarchy/Arch with neither).
@@ -224,7 +236,7 @@ async function readBody(req) {
  *
  *  Sniffing NEVER delays a byte: each chunk is written to the client first and
  *  only then scanned. */
-function relay(res, upstream, onReceipt) {
+function relay(res, upstream, onReceipt, rewriter = null) {
   const headers = {};
   upstream.headers.forEach((v, k) => {
     if (!['transfer-encoding', 'connection', 'content-encoding', 'content-length'].includes(k)) headers[k] = v;
@@ -237,13 +249,20 @@ function relay(res, upstream, onReceipt) {
     body.on('error', () => res.destroy());
     res.on('close', () => body.destroy());
     body.on('end', resolve);
-    if (!sse || typeof onReceipt !== 'function') { body.pipe(res); return; }
-    const observe = billingObserver(onReceipt);
+    if (!sse || (typeof onReceipt !== 'function' && !rewriter)) { body.pipe(res); return; }
+    const observe = typeof onReceipt === 'function' ? billingObserver(onReceipt) : () => {};
+    // A rewriter (Responses tool un-flattening) needs whole `data:` lines, so
+    // it re-chunks on newlines; the billing sniff reads the rewritten text,
+    // which leaves the trailing receipt comment untouched.
     body.on('data', (c) => {
-      res.write(c);
-      observe(c.toString('utf8'));
+      const text = rewriter ? rewriter.push(c.toString('utf8')) : c;
+      if (text.length) res.write(text);
+      observe(text.toString('utf8'));
+    });
+    body.on('end', () => {
+      if (rewriter) { const rest = rewriter.flush(); if (rest) { res.write(rest); observe(rest); } }
+      res.end();
     });
-    body.on('end', () => res.end());
   });
 }
 
@@ -769,9 +788,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // The BODY IS NOT TOUCHED — the parse below is read-only, to learn the
     // client's streaming intent for the JSON→SSE compatibility path.
     const isChat = req.method === 'POST' && rawPath.includes('/chat/completions');
+    const isResponses = req.method === 'POST' && /\/responses$/.test(rawPath);
     const isPaidPost = req.method === 'POST'
       && /\/(chat\/completions|completions|messages|responses)$/.test(rawPath);
     let wantsStream = false;
+    // Flat-name → {namespace, name} for this request's Responses tools; set
+    // only when the body was flattened, so the reply can be un-flattened.
+    let nsMap = null;
     // RECEIPTS ARE OPT-OUT. `disableStats: true` in the body (or the
     // x-openzoo-disable-stats header) means this caller does not want the x402
     // block, so we neither attach our settle proof nor pass the gateway's
@@ -843,6 +866,23 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           }
         }
       } catch { /* not JSON */ }
+      // RESPONSES TOOL GROUPS vs HOUSE DOORS. Codex sends `namespace` tool
+      // groups + `web_search`; abliterated-model* rejects both with a PAID
+      // 400 `invalid_tools`. Flatten before the wire for models known to
+      // need it (catalog house doors, or learned from a prior 400 below).
+      if (isResponses) {
+        try {
+          const parsed = JSON.parse(bodyBuf.toString('utf8'));
+          if (parsed && wantsFlatTools(parsed.model)) {
+            const flat = flattenResponsesTools(parsed);
+            if (flat.map) {
+              nsMap = flat.map;
+              bodyBuf = Buffer.from(JSON.stringify(flat.body));
+              say(`   tools flattened for ${parsed.model}: ${flat.map.size} namespaced → function${flat.dropped.length ? `, dropped ${flat.dropped.join(', ')}` : ''}`);
+            }
+          }
+        } catch { /* not JSON */ }
+      }
     }
 
     // Retry of a body we answered seconds ago? Serve the cached completion —
@@ -958,6 +998,56 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           result = await client.fetch(url, init);
         }
       }
+      // A 5xx IS NOT A REASON TO CHANGE THE MODEL. An earlier build routed any
+      // gateway 5xx to OPENZOO_OUTAGE_FALLBACK and gated the model 60s. That
+      // was wrong twice over: `/model fable-5.1` then reported `x402 door for
+      // grok-4.6 failed`, so the caller read an error for a model they never
+      // picked, and a silent substitution bills them for a DIFFERENT model's
+      // answer than the one they chose and are reading. When the requested
+      // model's door is down, say so about THAT model and let the caller
+      // decide. Only the 402 "insufficient credits" branch above still
+      // reroutes, because there the gateway itself refunds and the request
+      // was never served at all.
+      const RETRYABLE_5XX = new Set([500, 502, 503, 504]);
+      if (RETRYABLE_5XX.has(result.response?.status)) {
+        let detail = '';
+        try { const j = await result.response.clone().json(); detail = String(j?.error?.message || j?.error || '').slice(0, 300); } catch { /* opaque 5xx */ }
+        log(`upstream ${result.response.status} for ${outageKey(init)}${detail ? `: ${detail}` : ''} — surfacing as-is, model NOT swapped`);
+        // "no door quoted <model>: … wrong asset/rail (base)" IS AN EMPTY
+        // WALLET WEARING A 502. Measured 2026-09-13: Solana USDC ran down to
+        // dust, the rail picker fell through to Base (which held $0.0016), and
+        // every door that only quotes Solana refused the offer — grok-4.6,
+        // deepseek and fable all "502"d while abliterated-model (~$0.0005/call)
+        // still paid out of the dust and looked fine. The raw 502 sent the
+        // harness into a reconnect storm and read like a dead model. Say what
+        // it is, and name the model the caller actually asked for.
+        if (/no door quoted|wrong asset\/rail/i.test(detail)) {
+          const rail = /\(([^)]+)\)/.exec(detail.match(/wrong asset\/rail \([^)]*\)/i)?.[0] || '')?.[1] || '';
+          let msg = `${outageKey(init)} could not be paid for: the x402 door refused the offer${rail ? ` on the ${rail} rail` : ''}. This is almost always an empty wallet on the rail that door takes — the request never reached the model, and nothing was charged.`;
+          msg = await withOnrampLink(msg, { solana: client.address, evm: client.evmAddress, force: true });
+          jsonErr(res, 402, msg);
+          return;
+        }
+      }
+      // A PAID 400 `invalid_tools` on a Responses body we did not flatten:
+      // this model is a function-tools-only door we had not learned yet.
+      // Flatten, remember it, and buy the turn once more — one billed miss
+      // instead of every turn for the rest of the session.
+      if (isResponses && !nsMap && result.response?.status === 400) {
+        let e400 = null;
+        try { e400 = await result.response.clone().json(); } catch { e400 = null; }
+        if (isInvalidToolsError(e400)) {
+          let flat = null;
+          try { flat = flattenResponsesTools(JSON.parse(String(init.body || '{}'))); } catch { flat = null; }
+          if (flat?.map) {
+            flattenLearned.add(outageKey(init));
+            nsMap = flat.map;
+            init = { ...init, body: JSON.stringify(flat.body) };
+            say(`   invalid_tools from ${outageKey(init)} — flattened ${flat.map.size} namespaced tools${flat.dropped.length ? `, dropped ${flat.dropped.join(', ')}` : ''}; retrying`);
+            result = await client.fetch(url, init);
+          }
+        }
+      }
       const { response, paid, receipt, accept } = result;
       if (paid && receipt) {
         if (receipt.ok && typeof receipt.billedUsd === 'number') {
@@ -1038,6 +1128,16 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           res.end(JSON.stringify(data));
           return;
         }
+        // Un-flatten a JSON Responses reply so Codex can route the calls.
+        if (nsMap && data?.object === 'response') {
+          restoreResponsesPayload(data, nsMap);
+          const h = { 'content-type': 'application/json' };
+          const settleHdr = response.headers.get('x-payment-response');
+          if (settleHdr) h['x-payment-response'] = settleHdr;
+          res.writeHead(200, h);
+          res.end(JSON.stringify(data));
+          return;
+        }
       }
       // A STREAMED call is metered from the gateway's trailing SSE comment —
       // same figures the JSON path reads out of `data.x402`, same counters, so
@@ -1085,7 +1185,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         paymentError(res, req, init, paid ? copy.status : 402, msg);
         return;
       }
-      await relay(res, response, meterStreamed);
+      await relay(res, response, meterStreamed, nsMap ? sseNamespaceRestorer(nsMap) : null);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {
         log(err.message);

package/package.json

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