openzoo 0.49.18 → 0.50.1

package/bin/openzoo.js

@@ -106,10 +106,6 @@ usage:
                                           by default, --terminal for the Claude Code CLI
   npx openzoo launch <cmd> [args]   launch a TERMINAL Messages API client
                                     (claude, aider...) already pointed at the zoo
-  npx openzoo grokbot         KEEP Grok Bot's UI, serve YOUR RunPod box under it:
-                              spawns a CPU box, MITMs api2.cursor.sh, and answers
-                              EnsureSandBox with your box instead of a cursorvm pod.
-                              Inference x402-paid; needs RUNPOD_API_KEY + sudo.
   npx openzoo grok-cli        point the grok CLI at the zoo — GROK MODELS ONLY,
                               paid per call by x402 instead of xAI first-party billing,
                               then TAKE OVER the app's backend: pins api2.cursor.sh in
@@ -148,8 +144,6 @@ env:
   OPENZOO_RAIL (unset — force a rail: solana | base | robinhood)
   OPENZOO_BASE_RPC (https://mainnet.base.org)  OPENZOO_RH_RPC (rpc.mainnet.chain.robinhood.com)
   OPENZOO_MAX_USD_PER_CALL (unset — NO per-call ceiling; set to add one)  OPENZOO_DEMO_MAX_USD (0.01)
-  OPENZOO_CONTEXT_MIN_CHARS (16384 — bodies bigger than this bind once + reuse)
-  OPENZOO_NO_CONTEXT_CACHE (0 — set 1 to always ship the full body)
   OPENZOO_ENABLE_RH (0 — let DEFAULT selection fall through to the Robinhood rail;
                      OPENZOO_RAIL=robinhood forces it without this)
   OPENZOO_TUNNEL_MAX_USD (unset — NO public-url session ceiling; set to add one)  OPENZOO_TUNNEL_TOKEN (pin the api key)
@@ -167,9 +161,6 @@ async function main() {
       // GUI editors read config files, not env vars — see lib/setup.js.
       await (await import('../lib/setup.js')).setupEditor(cmd === 'editor' ? undefined : cmd, process.argv[3]);
       break;
-    case 'grokbot':
-      await (await import('../lib/grokbot.js')).runGrokBot(process.argv.slice(3));
-      break;
     case 'grok-cli':
     case 'grok':
       // Grok Bot (com.anysphere.sand) fronts the `grok` CLI, and the CLI reads

package/lib/models.js

@@ -1,11 +1,30 @@
 import { config } from './config.js';
 import { fetchHeaders } from './fetch.js';
-import {
-  AUTO_MODEL_ID, autoHasPricedModels, autoModelListEntry, isAutoModel,
-  isPricedTokenPair, isUnservableRouteId,
-} from './modelroute.js';
+// AUTO routing lives on the backend now; these helpers survive only so the
+// published catalog can EXCLUDE ids the gateway cannot serve (auto aliases,
+// :batch twins, $0 rows). The shim never routes.
+export const AUTO_MODEL_ID = 'openzoo/auto';
+export const AUTO_MODEL_ALIASES = new Set(['openzoo/auto', 'openzoo-auto', 'auto']);
 
-export { AUTO_MODEL_ID, isAutoModel, isPricedTokenPair, isUnservableRouteId };
+export function isAutoModel(id) {
+  return AUTO_MODEL_ALIASES.has(String(id || '').trim().toLowerCase());
+}
+
+/** Ids the gateway cannot quote for a chat turn (:batch twins, ~latest
+ *  pointers, openzoo-* aliases). The published catalog must never list them. */
+export function isUnservableRouteId(id) {
+  const s = String(id || '').trim();
+  if (!s) return true;
+  if (isAutoModel(s)) return false;
+  return s.includes(':batch') || s.startsWith('~') || s.startsWith('openzoo-');
+}
+
+/** Both sides must be a finite positive token price. $0 / NaN / missing 500. */
+export function isPricedTokenPair(priceIn, priceOut) {
+  const pin = Number(priceIn);
+  const pout = Number(priceOut);
+  return Number.isFinite(pin) && Number.isFinite(pout) && pin > 0 && pout > 0;
+}
 
 /** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
  *  module stays importable without the wallet/rpc stack. */
@@ -313,14 +332,9 @@ export function augmentModelList(payload, { aliases: withAliases = true } = {})
       };
     })
     : [];
-  const virtual = [];
-  // Auto is listed only when its own shortlist is priced models — never an
-  // unquoted OpenRouter id that 500s `bad openrouter price`.
-  if (!have.has(AUTO_MODEL_ID) && autoHasPricedModels(undefined, ids.length ? ids : null)) {
-    virtual.push(autoModelListEntry());
-    have.add(AUTO_MODEL_ID);
-  }
-  return { ...payload, object: payload?.object || 'list', data: [...virtual, ...data, ...aliases] };
+  // Auto is no longer published: routing lives on the backend, and a shim
+  // that advertises openzoo/auto would have to route it.
+  return { ...payload, object: payload?.object || 'list', data: [...data, ...aliases] };
 }
 
 /**
@@ -415,7 +429,6 @@ export function pickClaudePickerRows(rows) {
   for (const { prefer, re } of CLAUDE_PICKER_GATEWAY) {
     add(ids.includes(prefer) ? prefer : newestMatching(ids, (id) => re.test(id)));
   }
-  add(AUTO_MODEL_ID);
   return picked.map((id) => byId.get(id)).filter(Boolean);
 }
 
@@ -462,200 +475,3 @@ export function wantsAnthropicModelList(headers = {}) {
 export function modelsListForRequest(payload, headers) {
   return wantsAnthropicModelList(headers) ? anthropicModelList(payload) : publishModelList(payload);
 }
-
-/**
- * Which request paths carry a rewritable model field. POST-only; embeddings /
- * audio / image / moderation models are DIFFERENT model families — rewriting
- * a chat model into those would corrupt the call, so they pass untouched.
- */
-export function rewritablePath(method, url) {
-  if (method !== 'POST') return false;
-  const p = (url || '').split('?')[0];
-  return !/embed|audio|image|moderation/.test(p);
-}
-
-/**
- * Families that spend max_tokens on hidden thinking first. A 16/40/160
- * budget on these returns an empty visible completion — measured on Grok
- * and DeepSeek. The raise in raiseReasoningMaxTokens exists for that.
- * It must NEVER fire on Claude Code's 16-token auto-mode classifier.
- */
-export const REASONING_MODEL_RE = /(deepseek|grok|o[134](-|$)|reasoner|thinking|-pro\b|sol-pro|qwq)/i;
-
-/** Claude Code auto-mode classify is max_tokens=16. 0.48.75 used 64 and
- *  missed grok nubs at 128 / 2000 on a 1–2 message body (dead-steady ~3¢
- *  from the reasoning floor). Anything in (0, 256] on a short transcript
- *  is a nub; a fat grok chat still uses the 4000 floor. */
-export const CLASSIFY_MAX_TOKENS = 256;
-export const CLASSIFY_MAX_MSGS = 3;
-export const CLASSIFY_MAX_BODY = 65_536;
-
-const CLASSIFIER_PREFS = ['google/gemini-3.7-flash', 'anthropic/claude-haiku-4.5'];
-
-function messageHasToolCalls(m) {
-  return Boolean(
-    (Array.isArray(m?.tool_calls) && m.tool_calls.length)
-    || m?.function_call
-    || m?.role === 'tool',
-  );
-}
-
-/**
- * Tiny classify / grok nub: pin to flash, never apply the reasoning floor.
- *
- * 0.48.75 required max_tokens ≤ 64 AND body < BIND_MIN (16k). Live 3¢
- * asks missed that (max_tokens 128 or 2000, and/or body ≥ 16k from a
- * tools schema) and then ate the 4000 grok floor. Widen:
- *   - max_tokens ≤ 256 on a short transcript (≤ 6 msgs, no tool_calls)
- *   - OR few messages, no tool_calls, body under a few tens of KB
- *     (even when the caller asked for 2000 tokens)
- * A real grok chat (max_tokens 2000+ AND a long / tool-using transcript)
- * still returns false so the floor can fire.
- *
- * `body` may be the raw Buffer/string or a parsed object. An optional
- * `bodyLen` overrides stringify length when the caller still has the wire
- * bytes (the proxy does).
- */
-export function isTinyClassify(body, bodyLen) {
-  let parsed = body;
-  let len = bodyLen;
-  if (body == null) return false;
-  if (typeof body === 'string' || Buffer.isBuffer(body)) {
-    const buf = Buffer.isBuffer(body) ? body : Buffer.from(body);
-    len = buf.length;
-    try { parsed = JSON.parse(buf.toString('utf8')); } catch { return false; }
-  } else if (len == null) {
-    try { len = Buffer.byteLength(JSON.stringify(body)); } catch { return false; }
-  }
-  const mt = Number(parsed?.max_tokens);
-  if (!Number.isFinite(mt) || mt <= 0) return false;
-  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
-  if (messages.some(messageHasToolCalls)) return false;
-  if (mt <= CLASSIFY_MAX_TOKENS && messages.length <= 6) return true;
-  return messages.length <= CLASSIFY_MAX_MSGS && len < CLASSIFY_MAX_BODY;
-}
-
-/**
- * Ids that must never serve Claude Code / grokui AUTO's tiny yes/no classify.
- * REASONING_MODEL_RE is the thinking floor; HEAVY_RE is the flagship set
- * (opus/pro/max/…). opus-5 is openzoo's default session model and does NOT
- * match the reasoning regex, so a catalog that lists opus before flash — or
- * lists only opus + grok — used to pick opus as "first non-reasoner". That
- * classify is a 402 handshake on a big model; AUTO's timeout then hard-blocks
- * Bash instead of prompting.
- */
-function isSlowClassifier(id) {
-  const s = String(id || '');
-  return REASONING_MODEL_RE.test(s) || HEAVY_RE.test(s);
-}
-
-/**
- * Fast non-reasoning id that is actually on the zoo. Prefer an explicit
- * OPENZOO_CLASSIFIER_MODEL, then flash, then haiku, then the first catalog
- * id that is neither a reasoner nor a heavy/flagship (opus/pro/max/…).
- */
-export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIFIER_MODEL) {
-  if (!Array.isArray(ids) || !ids.length) return null;
-  if (preferred && ids.includes(preferred)) return preferred;
-  for (const id of CLASSIFIER_PREFS) {
-    if (ids.includes(id)) return id;
-  }
-  return ids.find((id) => !isSlowClassifier(id)) || null;
-}
-
-/**
- * Raise max_tokens for a reasoning model. Returns { parsed, raised, from, to }.
- * Does not itself decide whether a request is a classify — callers skip this
- * when isTinyClassify is true. Real Grok/DeepSeek chats still need the floor:
- * 4× a caller's 40 is 160, and those still come back blank.
- */
-export function raiseReasoningMaxTokens(parsed, env = process.env) {
-  const mult = Number(env.OPENZOO_REASONING_MAX_TOKENS_X || 4);
-  const cap = Number(env.OPENZOO_REASONING_MAX_TOKENS_CAP || 32000);
-  const floor = Number(env.OPENZOO_REASONING_MIN_TOKENS || 4000);
-  const mdl = String(parsed?.model || '');
-  const mt = Number(parsed?.max_tokens);
-  if (mult > 1 && REASONING_MODEL_RE.test(mdl) && Number.isFinite(mt) && mt > 0 && mt < cap) {
-    const raised = Math.min(cap, Math.max(floor, Math.round(mt * mult)));
-    if (raised > mt) {
-      return { parsed: { ...parsed, max_tokens: raised }, raised: true, from: mt, to: raised };
-    }
-  }
-  return { parsed, raised: false, from: mt, to: mt };
-}
-
-/**
- * Model + max_tokens policy for one chat body.
- *
- * Tiny classify: pin to a fast non-reasoning catalog id, leave max_tokens
- * alone, ignore OPENZOO_DEFAULT_MODEL. Never fall back to `from` when that
- * id is a reasoner or a heavy/flagship (the zoo default is opus-5). A
- * catalog miss or an opus-only list used to keep the classify on opus-5
- * and AUTO hard-blocked Bash. Everything else: resolveModel (which honours
- * the default) then the reasoning floor.
- */
-export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
-  const from = parsed?.model;
-  const len = bodyLen ?? (parsed == null ? 0 : Buffer.byteLength(JSON.stringify(parsed)));
-  if (isAutoModel(from) && !isTinyClassify(parsed, len)) {
-    return { parsed, tiny: false, auto: true, from, to: AUTO_MODEL_ID, raised: false };
-  }
-  if (isTinyClassify(parsed, len)) {
-    const picked = pickClassifierModel(ids);
-    // pickClassifierModel returns null on an empty catalog or a zoo that
-    // only lists reasoners/heavies. `(picked) || from` left those on
-    // anthropic/claude-opus-5 (openzoo's default). Pin to flash instead —
-    // never ship a classify body AUTO would time out and hard-block on.
-    const to = picked || (typeof from === 'string' && !isSlowClassifier(from) ? from : CLASSIFIER_PREFS[0]);
-    return {
-      parsed: (to && to !== from) ? { ...parsed, model: to } : parsed,
-      tiny: true,
-      from,
-      to,
-      raised: false,
-    };
-  }
-  if (typeof from !== 'string') {
-    return { parsed, tiny: false, from, to: from, raised: false };
-  }
-  const resolved = resolveModel(from, ids) || anthropicNativeAlias(from);
-  const next = resolved ? { ...parsed, model: resolved } : parsed;
-  const bump = raiseReasoningMaxTokens(next);
-  return {
-    parsed: bump.parsed,
-    tiny: false,
-    from,
-    to: next.model,
-    raised: bump.raised,
-    raisedFrom: bump.from,
-    raisedTo: bump.to,
-  };
-}
-
-/**
- * Rewrite the model field of any request body that has one.
- * Returns null (send as-is) or { body, from, to, tiny?, raised? }. Any
- * failure — bad JSON, unreachable catalog — returns null: this layer must
- * never break a call that would have worked without it.
- *
- * Tiny classify is pinned here too, so OPENZOO_DEFAULT_MODEL cannot capture
- * a 16-token yes/no even if a caller only goes through this helper.
- */
-export async function maybeRewriteModel(bodyBuf) {
-  let body;
-  try { body = JSON.parse(bodyBuf.toString('utf8')); } catch { return null; }
-  if (typeof body?.model !== 'string') return null;
-  let ids;
-  try { ids = await zooModelIds(); } catch { return null; }
-  const policy = rewriteChatModel(body, ids, { bodyLen: bodyBuf.length });
-  if (!policy.tiny && !policy.raised && policy.to === body.model) return null;
-  return {
-    body: Buffer.from(JSON.stringify(policy.parsed)),
-    from: body.model,
-    to: policy.parsed.model,
-    tiny: policy.tiny,
-    raised: policy.raised,
-    raisedFrom: policy.raisedFrom,
-    raisedTo: policy.raisedTo,
-  };
-}