openzoo 0.48.71 → 0.48.74

package/lib/models.js

@@ -1,5 +1,9 @@
 import { config } from './config.js';
 
+/** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
+ *  module stays importable without the wallet/rpc stack. */
+const BIND_MIN_CHARS = Number(process.env.OPENZOO_CONTEXT_MIN_CHARS || 16384);
+
 /**
  * Model-id rewriting — "any harness, zero model setup".
  *
@@ -257,11 +261,124 @@ export function rewritablePath(method, url) {
   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; treat anything in (0, 64] as one. */
+export const CLASSIFY_MAX_TOKENS = 64;
+
+const CLASSIFIER_PREFS = ['google/gemini-3.7-flash', 'anthropic/claude-haiku-4.5'];
+
+/**
+ * Tiny yes/no classify: small body (same BIND_MIN threshold the spill/brief
+ * already use) AND a short max_tokens. Detected from the ORIGINAL body,
+ * before rewrite or the reasoning floor — otherwise OPENZOO_DEFAULT_MODEL
+ * can land the classify on Grok/DeepSeek and the floor turns 16 into 4000.
+ *
+ * `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);
+  return len < BIND_MIN_CHARS && Number.isFinite(mt) && mt > 0 && mt <= CLASSIFY_MAX_TOKENS;
+}
+
+/**
+ * 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 does not match the reasoning regex.
+ */
+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) => !REASONING_MODEL_RE.test(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. 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 (isTinyClassify(parsed, len)) {
+    const to = (typeof from === 'string' && pickClassifierModel(ids)) || from;
+    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);
+  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 }. Any failure — bad JSON,
- * unreachable catalog — returns null: this layer must never break a call
- * that would have worked without it.
+ * 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;
@@ -269,7 +386,15 @@ export async function maybeRewriteModel(bodyBuf) {
   if (typeof body?.model !== 'string') return null;
   let ids;
   try { ids = await zooModelIds(); } catch { return null; }
-  const to = resolveModel(body.model, ids);
-  if (!to) return null;
-  return { body: Buffer.from(JSON.stringify({ ...body, model: to })), from: body.model, to };
+  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,
+  };
 }