openzoo 0.51.28 → 0.51.30

package/README.md

@@ -283,7 +283,7 @@ The rail is chosen from the 402's `accepts[]` itself (Solana first). **Steer it
 | `OPENZOO_RPC` | mainnet-beta public RPC | Solana RPC |
 | `OPENZOO_TOKEN` | (internal) | preferred 402 rail — leave unset |
 | `OPENZOO_RAIL` | (unset) | force a rail: `solana` \| `base` \| `robinhood`. Errors if the live 402 doesn't offer it |
-| `OPENZOO_BASE_RPC` | `https://mainnet.base.org` | Base RPC (balances / preflight) |
+| `OPENZOO_BASE_RPC` | `https://base-rpc.publicnode.com` | Base RPC (balances / preflight) |
 | `OPENZOO_RH_RPC` | `https://rpc.mainnet.chain.robinhood.com` | Robinhood Chain RPC (balances / preflight) |
 | `OPENZOO_WALLET` | `~/.openzoo/wallet.json` | wallet path |
 | `OPENZOO_MAX_USD_PER_CALL` | `0.5` | refuse quotes above this |

package/lib/config.js

@@ -20,7 +20,7 @@ export const config = {
   // pickAccept errors clearly when the live 402 does not offer the forced rail.
   rail: (process.env.OPENZOO_RAIL || '').toLowerCase() || null,
   // EVM RPCs for balance reads / preflight checks on the Base and RH rails.
-  baseRpcUrl: process.env.OPENZOO_BASE_RPC || 'https://mainnet.base.org',
+  baseRpcUrl: process.env.OPENZOO_BASE_RPC || 'https://base-rpc.publicnode.com',
   rhRpcUrl: process.env.OPENZOO_RH_RPC || 'https://rpc.mainnet.chain.robinhood.com',
   walletPath: process.env.OPENZOO_WALLET || path.join(os.homedir(), '.openzoo', 'wallet.json'),
   // Refuse to auto-pay any single 402 quote above this many USD (extra.billedUsd).

package/lib/modelcommand.js

@@ -217,23 +217,113 @@ export function clearOverride(file = modelFilePath()) {
   memo = { file: null, stamp: null, id: null };
 }
 
+// ---------------------------------------------------------------------------
+// PER-CHAT OVERRIDES — `~/.openzoo/models.json`, keyed by the harness's own
+// conversation id.
+//
+// THE FAILURE THIS EXISTS FOR. `~/.openzoo/model` is ONE line for the whole
+// machine, so two ChatGPT windows could not hold two models: `/model
+// abliterated` in window A and `/model fable-5.1` in window B left BOTH on
+// whichever was typed last. Window A then answered as fable and looked like it
+// was lying about its own identity. Codex sends a stable per-conversation id
+// (`thread-id` / `session-id` headers, `prompt_cache_key`, and `session_id`
+// inside client_metadata), all equal per chat and different across chats, so
+// the override can be keyed by chat and the windows stop fighting.
+//
+// The single-line file stays the machine-wide DEFAULT: a harness that sends no
+// conversation id (curl, `openzoo model X`, older clients) still reads and
+// writes it, and a chat with no entry of its own falls back to it.
+// ---------------------------------------------------------------------------
+
+export function chatModelsPath(home = os.homedir()) {
+  return path.join(home, '.openzoo', 'models.json');
+}
+
+/** The conversation id for this request, or '' when the caller has no notion
+ *  of one. Header first (cheapest, and Codex sets several that agree); the
+ *  window id carries a `:0` pane suffix that must survive — two panes of one
+ *  window are two chats. */
+export function chatKeyFrom(headers = {}, body = null) {
+  const h = (k) => {
+    const v = headers?.[k] ?? headers?.[String(k).toLowerCase()];
+    return Array.isArray(v) ? v[0] : v;
+  };
+  const fromHeader = h('thread-id') || h('session-id') || h('x-codex-window-id');
+  if (fromHeader) return String(fromHeader).trim();
+  if (body && typeof body.prompt_cache_key === 'string' && body.prompt_cache_key) {
+    return body.prompt_cache_key.trim();
+  }
+  try {
+    const meta = body?.client_metadata;
+    const sid = meta?.session_id
+      || JSON.parse(String(meta?.['x-codex-turn-metadata'] || '{}'))?.session_id;
+    if (sid) return String(sid).trim();
+  } catch { /* metadata is advisory */ }
+  return '';
+}
+
+function readChatMap(file = chatModelsPath()) {
+  try {
+    const j = JSON.parse(readFileSync(file, 'utf8'));
+    return j && typeof j === 'object' && !Array.isArray(j) ? j : {};
+  } catch { return {}; }
+}
+
+function writeChatMap(map, file = chatModelsPath()) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  // Newest last, capped: a long-lived proxy would otherwise accumulate an
+  // entry per chat forever. 500 is far past any real window count.
+  const keys = Object.keys(map);
+  const trimmed = keys.length > 500
+    ? Object.fromEntries(keys.slice(-500).map((k) => [k, map[k]]))
+    : map;
+  writeFileSync(file, `${JSON.stringify(trimmed, null, 2)}\n`);
+}
+
+/** This chat's model: its own entry, else the machine-wide default. */
+export function readOverrideFor(key, file = modelFilePath(), chatFile = chatModelsPath()) {
+  if (key) {
+    const hit = readChatMap(chatFile)[key];
+    if (typeof hit === 'string' && hit) return hit;
+  }
+  return readOverride(file);
+}
+
+export function writeOverrideFor(key, id, file = modelFilePath(), chatFile = chatModelsPath()) {
+  if (!key) return writeOverride(id, file);
+  const map = readChatMap(chatFile);
+  map[key] = id;
+  writeChatMap(map, chatFile);
+  return id;
+}
+
+export function clearOverrideFor(key, file = modelFilePath(), chatFile = chatModelsPath()) {
+  if (!key) { clearOverride(file); return; }
+  const map = readChatMap(chatFile);
+  delete map[key];
+  writeChatMap(map, chatFile);
+}
+
 const RESET_WORDS = new Set(['reset', 'default', 'off', 'none', 'clear']);
 
 /**
  * Run the command and return what to say back. Pure apart from the one file
  * write, so the reply text is testable.
  */
-export function applyModelCommand(arg, ids, file = modelFilePath()) {
-  const current = readOverride(file);
+export function applyModelCommand(arg, ids, file = modelFilePath(), key = '') {
+  // `key` is this chat's conversation id (see chatKeyFrom). Empty = the
+  // machine-wide default file, which is what non-Codex callers get.
+  const current = readOverrideFor(key, file);
+  const scope = key ? 'This chat' : 'Every chat';
   const wanted = String(arg || '').trim();
   if (!wanted) {
     return { text: statusText(current, ids), model: current || 'openzoo', changed: false };
   }
   if (RESET_WORDS.has(wanted.toLowerCase())) {
-    clearOverride(file);
+    clearOverrideFor(key, file);
     return {
       text: current
-        ? `Cleared the model override (was ${current}). Chats now use whatever the app sends.`
+        ? `Cleared the model override (was ${current}). ${key ? 'This chat' : 'Chats'} now use${key ? 's' : ''} whatever the app sends.`
         : 'No model override was set. Chats use whatever the app sends.',
       model: 'openzoo',
       changed: Boolean(current),
@@ -245,9 +335,9 @@ export function applyModelCommand(arg, ids, file = modelFilePath()) {
     // the command useless exactly when the gateway is flaky, so take the id as
     // typed and say so — the next real request surfaces a wrong id anyway.
     if (!Array.isArray(ids) || !ids.length) {
-      writeOverride(wanted, file);
+      writeOverrideFor(key, wanted, file);
       return {
-        text: `Could not reach the model catalog, so I took "${wanted}" as typed. Every chat from here uses it until you send /model reset.`,
+        text: `Could not reach the model catalog, so I took "${wanted}" as typed. ${scope} from here uses it until you send /model reset.`,
         model: wanted,
         changed: true,
       };
@@ -261,9 +351,9 @@ export function applyModelCommand(arg, ids, file = modelFilePath()) {
       changed: false,
     };
   }
-  writeOverride(hit, file);
+  writeOverrideFor(key, hit, file);
   return {
-    text: `Switched to ${hit}. Every chat from here uses it until you send /model reset.`,
+    text: `Switched to ${hit}. ${scope} from here uses it until you send /model reset.`,
     model: hit,
     changed: hit !== current,
   };

package/lib/proxy.js

@@ -20,7 +20,7 @@ import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { autoContext } from './autobind.js';
 import { modelsListForRequest, isHarnessAliasId, resolveModel, quoteableRows, unopenrouter } from './models.js';
-import { detectModelCommand, applyModelCommand, serveModelCommand, readOverride } from './modelcommand.js';
+import { detectModelCommand, applyModelCommand, serveModelCommand, readOverrideFor, chatKeyFrom } from './modelcommand.js';
 
 /**
  * Quoteable catalog ids, cached 5 minutes, for the fuzzy /v1/models/<id> probe.
@@ -829,8 +829,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (cmd) {
           let ids = [];
           try { ids = await catalogIdsCached(`${config.apiBase}/v1/models`, upstreamHeaders(req)); } catch { /* offline: applyModelCommand takes the id as typed */ }
-          const out = applyModelCommand(cmd.arg, ids);
-          say(`   /model ${cmd.arg || '(status)'} — answered locally, nothing paid`);
+          const chatKey = chatKeyFrom(req.headers, parsed);
+          const out = applyModelCommand(cmd.arg, ids, undefined, chatKey);
+          say(`   /model ${cmd.arg || '(status)'} — answered locally, nothing paid${chatKey ? ` (chat ${chatKey.slice(0, 8)})` : ''}`);
           if (out.changed) saidOverride = null;
           serveModelCommand(res, {
             rawPath, stream: wantsStream, text: out.text, model: out.model, serveAsSse,
@@ -840,7 +841,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // THE OVERRIDE ITSELF. Applied before the replay key so a switched
         // model is a different cache entry, and before pay so the 402 is quoted
         // for the model that will actually answer.
-        const override = readOverride();
+        // Per-chat first, machine default second — two ChatGPT windows hold
+        // two different models because Codex keys each by thread-id.
+        const override = readOverrideFor(chatKeyFrom(req.headers, parsed));
         if (override && parsed && typeof parsed.model === 'string' && parsed.model !== override) {
           const pair = `${parsed.model} -> ${override}`;
           if (saidOverride !== pair) { say(`   model override: ${pair}`); saidOverride = pair; }
@@ -963,7 +966,16 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       // x402 door for bare grok-4.6 settles cogs on chain and never touches
       // OpenRouter. When a model is gated (or comes back "Insufficient
       // credits" below), the same request goes out once more on the fallback.
-      const FALLBACK_MODEL = String(process.env.OPENZOO_OUTAGE_FALLBACK || 'grok-4.6');
+      // NEVER SWAP THE CALLER'S MODEL. This defaulted to `grok-4.6`, so an
+      // outage on the model you picked silently bought a DIFFERENT model —
+      // `/model abliterated` and `/model fable-5.1` both reported `x402 door
+      // for grok-4.6 failed`, an error naming a model the caller never chose,
+      // while billing them for an answer from that other model. Empty by
+      // default: every swap below is guarded by `if (FALLBACK_MODEL && …)`, so
+      // this one line turns them all off and the real error surfaces against
+      // the model that was actually requested. Set OPENZOO_OUTAGE_FALLBACK
+      // explicitly to opt back in.
+      const FALLBACK_MODEL = String(process.env.OPENZOO_OUTAGE_FALLBACK || '');
       const withModel = (i, model) => {
         try { const b = JSON.parse(String(i.body || '{}')); b.model = model; return { ...i, body: JSON.stringify(b) }; } catch { return i; }
       };

package/package.json

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