openzoo 0.49.7 → 0.49.9

package/lib/models.js

@@ -1,5 +1,11 @@
 import { config } from './config.js';
 import { fetchHeaders } from './fetch.js';
+import {
+  AUTO_MODEL_ID, autoHasPricedModels, autoModelListEntry, isAutoModel,
+  isPricedTokenPair, isUnservableRouteId,
+} from './modelroute.js';
+
+export { AUTO_MODEL_ID, isAutoModel, isPricedTokenPair, isUnservableRouteId };
 
 /** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
  *  module stays importable without the wallet/rpc stack. */
@@ -50,18 +56,43 @@ export function editorSlot(id) {
 }
 
 const CATALOG_TTL_MS = 5 * 60 * 1000;
-let cache = { at: 0, ids: null };
+let cache = { at: 0, ids: null, base: null };
+
+export function resetZooModelIdsCache() {
+  cache = { at: 0, ids: null, base: null };
+}
 
 export async function zooModelIds() {
-  if (cache.ids && Date.now() - cache.at < CATALOG_TTL_MS) return cache.ids;
+  if (cache.ids && cache.base === config.apiBase && Date.now() - cache.at < CATALOG_TTL_MS) return cache.ids;
   const r = await fetchHeaders(`${config.apiBase}/v1/models`);
   if (!r.ok) throw new Error(`model catalog fetch failed: HTTP ${r.status}`);
   const d = await r.json();
-  const ids = (d.data || []).map((m) => m.id).filter(Boolean);
-  if (ids.length) cache = { at: Date.now(), ids };
+  const ids = quoteableRows(d.data).map((m) => m.id).filter((id) => id && !isAutoModel(id));
+  if (ids.length) cache = { at: Date.now(), ids, base: config.apiBase };
   return ids;
 }
 
+/** OpenRouter / gateway token price pair. Image/video rows have no prompt. */
+export function tokenPricePair(pricing) {
+  if (!pricing || typeof pricing !== 'object') return [NaN, NaN];
+  return [Number(pricing.prompt ?? pricing.input), Number(pricing.completion ?? pricing.output)];
+}
+
+/**
+ * A row the gateway can actually quote for chat. Drops :batch, ~latest
+ * pointers, openzoo-* twins, $0 / missing / non-token OpenRouter prices.
+ */
+export function isQuoteableModel(m) {
+  const id = m?.id;
+  if (isAutoModel(id)) return true;
+  if (isUnservableRouteId(id)) return false;
+  return isPricedTokenPair(...tokenPricePair(m?.pricing));
+}
+
+export function quoteableRows(data) {
+  return (Array.isArray(data) ? data : []).filter(isQuoteableModel);
+}
+
 /** Vendor fingerprints in harness model ids → zoo catalog prefixes. Order
  *  matters only for overlapping hints; first match wins. */
 const FAMILIES = [
@@ -119,6 +150,14 @@ const tokensOf = (id) => id.toLowerCase().split(/[^a-z0-9.]+/).filter((t) => t &
  * OPENZOO_DEFAULT_MODEL is an explicit user override, not a fallback tier.
  */
 export function resolveModel(requested, ids) {
+  // Virtual router id — never family-match, never steal via OPENZOO_DEFAULT_MODEL.
+  if (isAutoModel(requested)) return null;
+  // Bare Anthropic / Claude Code ids are never live on Fly/OpenRouter
+  // (`claude-opus-5` → 500 unknown model). Rewrite even on a catalog miss
+  // or if a gateway row lists the bare name — the request must not leave
+  // the sidecar as that id.
+  const native = anthropicNativeAlias(requested);
+  if (native) return native;
   if (!requested || !ids?.length || ids.includes(requested)) return null;
   // `openzoo-` prefixed names exist so an editor cannot mistake them for its
   // OWN models: Cursor claims any name in its catalog (claude-opus-5, grok-4.6)
@@ -187,6 +226,46 @@ export function resolveModel(requested, ids) {
   return best;
 }
 
+/**
+ * Bare Anthropic / Claude Code ids. MEASURED 2026-08-20 against Fly
+ * x402-tokens: POST /v1/chat/completions model=claude-opus-5 → 500
+ * `unknown model claude-opus-5`. The vendor-prefixed twin
+ * (`anthropic/claude-opus-5`) 402s and is priced. Claude Code's Auto
+ * permission classifier calls these ids on ANTHROPIC_BASE_URL; if the
+ * sidecar forwards the bare name, Bash hangs with
+ * "claude-opus-5 is temporarily unavailable, so auto mode cannot
+ * determine the safety of Bash". Always rewrite. Never send the bare
+ * id to OpenRouter / Fly. Do not push x402-tokens — alias here.
+ */
+export const ANTHROPIC_NATIVE_ALIASES = {
+  'claude-opus-5': 'anthropic/claude-opus-5',
+  'claude-opus-5-fast': 'anthropic/claude-opus-5-fast',
+  'claude-3-5-opus': 'anthropic/claude-opus-5',
+  'claude-sonnet-5': 'anthropic/claude-sonnet-5',
+  'claude-sonnet-5-fast': 'anthropic/claude-sonnet-5',
+  'claude-opus-4-8': 'anthropic/claude-opus-4.8',
+  'claude-opus-4.8': 'anthropic/claude-opus-4.8',
+  'claude-fable-5': 'anthropic/claude-fable-5',
+  'claude-haiku-4.5': 'anthropic/claude-haiku-4.5',
+};
+
+/** Claude Code sometimes suffixes a window marker (`claude-opus-5[1m]`). */
+function stripAnthropicWindowSuffix(id) {
+  return String(id || '').trim().replace(/\[[\d]+m\]$/i, '');
+}
+
+/**
+ * Priced zoo twin for a bare Anthropic / Claude Code id, or null.
+ * Vendor-prefixed ids and openzoo-* twins are left to the rest of resolveModel.
+ */
+export function anthropicNativeAlias(requested) {
+  if (!requested || typeof requested !== 'string') return null;
+  const stripped = stripAnthropicWindowSuffix(requested);
+  if (!stripped || stripped.includes('/')) return null;
+  if (/^openzoo[-/]/i.test(stripped)) return null;
+  return ANTHROPIC_NATIVE_ALIASES[stripped] || ANTHROPIC_NATIVE_ALIASES[stripped.toLowerCase()] || null;
+}
+
 /**
  * Ids harnesses ship as DEFAULTS (Cursor, Continue, Aider, Codex CLI, Cline,
  * OpenClaw, LangChain templates…). Merged into GET /v1/models so a harness
@@ -197,58 +276,153 @@ export const ALIAS_IDS = [
   'gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4-turbo', 'gpt-3.5-turbo',
   'gpt-5', 'gpt-5-mini', 'chatgpt-4o-latest', 'o1', 'o3', 'o3-mini', 'o4-mini',
   'claude-3-5-sonnet-latest', 'claude-sonnet-4-0', 'claude-opus-4-1',
+  'claude-opus-5', 'claude-opus-5-fast', 'claude-3-5-opus', 'claude-sonnet-5',
+  'claude-opus-4-8', 'claude-fable-5',
   'gemini-2.5-pro', 'gemini-2.5-flash', 'grok-4', 'grok-3',
   'deepseek-chat', 'deepseek-reasoner', 'qwen-max', 'llama-3.3-70b',
 ];
 
+export function isHarnessAliasId(id) {
+  const stripped = stripAnthropicWindowSuffix(id);
+  return ALIAS_IDS.includes(stripped) || Boolean(anthropicNativeAlias(stripped));
+}
+
 /**
  * Merge alias rows into a /v1/models payload without duplicating real ids.
  * Each alias inherits context_length and pricing from the model it RESOLVES
  * to — a harness sizing its corpus off "gpt-4o" gets the real ceiling of the
  * model that will actually serve it, not a blank.
+ *
+ * Does not mint openzoo-* twins. Those duplicated every real id (and every
+ * :batch id) in Claude Code's /model picker.
  */
-export function augmentModelList(payload) {
-  const data = Array.isArray(payload?.data) ? payload.data : [];
+export function augmentModelList(payload, { aliases: withAliases = true } = {}) {
+  const data = quoteableRows(payload?.data);
   const have = new Set(data.map((m) => m.id));
   const ids = data.map((m) => m.id);
-  // openzoo-* twins of the popular models. An editor that validates a custom
-  // model against THIS list (Cursor's "Add model" box reports "No models
-  // available" for anything missing here) can only offer what we publish — and
-  // the openzoo- prefix is what stops it claiming the name as one of its own
-  // built-ins and routing to its backend instead of to us.
-  const branded = [];
-  for (const src0 of data) {
-    const id = src0.id;
-    // Brand only REAL upstream models. Anything we synthesised (a twin or a
-    // harness alias) must be skipped, or augmenting an already-augmented
-    // payload mints openzoo-openzoo-* and the catalog grows every pass.
-    if (!id || id.startsWith('openzoo-') || String(src0.owned_by || '').startsWith('openzoo')) continue;
-    const short = id.includes('/') ? id.split('/')[1] : id;
-    const name = `openzoo-${short}`;
-    if (have.has(name)) continue;
-    const src = data.find((m) => m.id === id);
-    branded.push({
-      id: name,
-      object: 'model',
-      owned_by: 'openzoo',
-      served_by: id,
-      ...(src?.context_length ? { context_length: src.context_length, context_window: src.context_window ?? src.context_length } : {}),
-      ...(src?.pricing ? { pricing: src.pricing } : {}),
-    });
-    have.add(name);
+  const aliases = withAliases
+    ? ALIAS_IDS.filter((id) => !have.has(id)).map((id) => {
+      const target = data.find((m) => m.id === resolveModel(id, ids));
+      return {
+        id,
+        object: 'model',
+        owned_by: 'openzoo-alias',
+        ...(target?.context_length ? { context_length: target.context_length, context_window: target.context_window ?? target.context_length } : {}),
+        ...(target?.pricing ? { pricing: target.pricing } : {}),
+        ...(target ? { served_by: target.id } : {}),
+      };
+    })
+    : [];
+  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);
   }
-  const aliases = ALIAS_IDS.filter((id) => !have.has(id)).map((id) => {
-    const target = data.find((m) => m.id === resolveModel(id, ids));
-    return {
-      id,
-      object: 'model',
-      owned_by: 'openzoo-alias',
-      ...(target?.context_length ? { context_length: target.context_length, context_window: target.context_window ?? target.context_length } : {}),
-      ...(target?.pricing ? { pricing: target.pricing } : {}),
-      ...(target ? { served_by: target.id } : {}),
-    };
-  });
-  return { ...payload, object: payload?.object || 'list', data: [...data, ...branded, ...aliases] };
+  return { ...payload, object: payload?.object || 'list', data: [...virtual, ...data, ...aliases] };
+}
+
+/**
+ * Label a catalog id for a picker without minting a new id.
+ * `x-ai/grok-4.6` stays `x-ai/grok-4.6` on the wire; the label is just
+ * "grok-4.6 (x-ai)". Never invents a `claude-*` name for a non-Anthropic animal.
+ */
+export function displayNameFor(id) {
+  const raw = String(id || '').trim();
+  if (!raw) return raw;
+  if (raw.includes('/')) {
+    const slash = raw.indexOf('/');
+    return `${raw.slice(slash + 1)} (${raw.slice(0, slash)})`;
+  }
+  return raw;
+}
+
+function decorateModelEntry(m) {
+  if (!m || typeof m !== 'object') return m;
+  return {
+    ...m,
+    object: m.object || 'model',
+    type: m.type || 'model',
+    display_name: m.display_name || displayNameFor(m.id),
+  };
+}
+
+/**
+ * OpenAI-compatible /v1/models body. Quoteable chat models only — no :batch,
+ * no unpriced / image-video rows, no openzoo-* twins. Extra Anthropic fields
+ * (`type`, `display_name`) sit alongside OpenAI ones.
+ */
+export function publishModelList(payload, opts) {
+  const merged = augmentModelList(payload, opts);
+  const data = (merged.data || []).map(decorateModelEntry);
+  return {
+    ...merged,
+    object: merged.object || 'list',
+    data,
+    has_more: false,
+    first_id: data[0]?.id ?? null,
+    last_id: data[data.length - 1]?.id ?? null,
+  };
+}
+
+function anthropicRows(rows) {
+  return rows.map((m) => ({
+    type: 'model',
+    id: m.id,
+    display_name: m.display_name || displayNameFor(m.id),
+    ...(m.created_at ? { created_at: m.created_at } : {}),
+    ...(m.served_by ? { served_by: m.served_by } : {}),
+  }));
+}
+
+/** openzoo/auto first so Claude Code's picker default is the router, not opus. */
+function withAutoFirst(rows) {
+  const list = Array.isArray(rows) ? rows.slice() : [];
+  const i = list.findIndex((m) => isAutoModel(m?.id));
+  if (i > 0) {
+    const [auto] = list.splice(i, 1);
+    list.unshift(auto);
+  }
+  return list;
+}
+
+/**
+ * Anthropic GET /v1/models shape (id + display_name + type).
+ * Claude Code gateway discovery reads `data[].id` and optional `display_name`.
+ * Full quoteable catalog — every priced published id, including OpenRouter
+ * grok/gemini/gpt rows. Not a 4-id Anthropic cap, not openzoo-* clones.
+ * Picker ≠ classifier: rewriteChatModel still pins 16-token classify off opus-5.
+ */
+export function anthropicModelList(payload) {
+  const published = publishModelList(payload, { aliases: false });
+  const data = anthropicRows(withAutoFirst(published.data || []));
+  return {
+    data,
+    has_more: false,
+    first_id: data[0]?.id ?? null,
+    last_id: data[data.length - 1]?.id ?? null,
+  };
+}
+
+/** Claude Code / Anthropic SDKs send anthropic-version or an x-app / UA hint. */
+export function wantsAnthropicModelList(headers = {}) {
+  const h = headers && typeof headers === 'object' ? headers : {};
+  const get = (k) => h[k] ?? h[k.toLowerCase()] ?? '';
+  return Boolean(get('anthropic-version'))
+    || /claude|anthropic/i.test(String(get('x-app')))
+    || /claude|anthropic/i.test(String(get('user-agent')));
+}
+
+/**
+ * Body for GET /v1/models. Quoteable catalog only (never opus-5-only, never
+ * unpriced / :batch / openzoo-* clones). Anthropic-shaped clients get the
+ * same quoteable ids in Anthropic shape (type / id / display_name) so Claude
+ * Code can select grok, gemini, gpt, etc. OpenAI clients keep object:list
+ * of every quoteable id + harness aliases.
+ */
+export function modelsListForRequest(payload, headers) {
+  return wantsAnthropicModelList(headers) ? anthropicModelList(payload) : publishModelList(payload);
 }
 
 /**
@@ -385,6 +559,9 @@ export function raiseReasoningMaxTokens(parsed, env = process.env) {
 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
@@ -403,7 +580,7 @@ export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
   if (typeof from !== 'string') {
     return { parsed, tiny: false, from, to: from, raised: false };
   }
-  const resolved = resolveModel(from, ids);
+  const resolved = resolveModel(from, ids) || anthropicNativeAlias(from);
   const next = resolved ? { ...parsed, model: resolved } : parsed;
   const bump = raiseReasoningMaxTokens(next);
   return {

package/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/pay.js

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { getAssociatedTokenAddressSync } from '@solana/spl-token';
-import { config, fundingLine, evmRpcFor } from './config.js';
+import { config, fundingLine, evmRpcFor, FUNDING_ASSETS } from './config.js';
 import { loadOrCreateWallet } from './wallet.js';
 import {
   parse402, orderAccepts, railOf, buildPaymentOnline, tokenBalance,
@@ -120,6 +120,37 @@ export function resetRailMemory() {
   lastGoodAsset = null;
 }
 
+/**
+ * Skip wrap / pool / sendWrap when there is nothing to convert.
+ * wrapped < need AND underlying == 0 → UnderfundedError, no RPC walk.
+ * A funded wallet (underlying > 0) still wraps.
+ */
+export function skipWrapWhenEmpty(wrappedRaw, underlyingRaw, need) {
+  const wrapped = wrappedRaw == null ? 0n : BigInt(wrappedRaw);
+  const underlying = underlyingRaw == null ? 0n : BigInt(underlyingRaw);
+  const want = need == null ? 0n : BigInt(need);
+  return wrapped < want && underlying <= 0n;
+}
+
+/**
+ * Cheap underlying mint for a 402 row — directory acquire address, or the
+ * known USDC / TOKEN / LEOS twin named in extra.symbol. No chain probe.
+ */
+export function hintedUnderlyingMint(accept) {
+  const acq = accept?.extra?.acquire?.underlying;
+  const addr = typeof acq === 'string' ? acq : acq?.address;
+  if (addr && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(addr)) return addr;
+  const plain = String(accept?.extra?.symbol || '').replace(/^[wy]/i, '').replace(/x$/i, '').toUpperCase();
+  return FUNDING_ASSETS.find((a) => a.symbol === plain)?.mint || null;
+}
+
+/** True when every Solana funding mint (USDC / TOKEN / LEOS) reads 0. */
+export function solanaFundingEmpty(balances) {
+  const rows = Array.isArray(balances) ? balances : [];
+  if (!rows.length) return false;
+  return rows.every((b) => (b?.raw == null ? 0n : BigInt(b.raw)) <= 0n);
+}
+
 export class PayClient {
   constructor() {
     const w = loadOrCreateWallet();
@@ -213,6 +244,11 @@ export class PayClient {
     }
   }
 
+  async solanaFundingBalances() {
+    const owner = this.keypair.publicKey;
+    return Promise.all(FUNDING_ASSETS.map((a) => cachedTokenBalance(this.connection, owner, a.mint)));
+  }
+
   async buildPaymentFor(accept, onStage) {
     const rail = railOf(accept);
     if (rail === 'solana') {
@@ -224,6 +260,22 @@ export class PayClient {
         bal = await cachedTokenBalance(this.connection, this.keypair.publicKey, accept.asset, { force: true });
       }
       if (bal.raw < need) {
+        // Empty first-run burner: 0 wrapped + 0 USDC/TOKEN/LEOS. Do not
+        // resolvePool / poolState / sendWrap just to learn that.
+        const funding = await this.solanaFundingBalances();
+        if (solanaFundingEmpty(funding)) {
+          throw new UnderfundedError(accept, 0, this.address);
+        }
+        const underMint = hintedUnderlyingMint(accept);
+        if (underMint) {
+          let under = await cachedTokenBalance(this.connection, this.keypair.publicKey, underMint);
+          if (under.raw <= 0n && under.cached) {
+            under = await cachedTokenBalance(this.connection, this.keypair.publicKey, underMint, { force: true });
+          }
+          if (skipWrapWhenEmpty(bal.raw, under.raw, need)) {
+            throw new UnderfundedError(accept, under.ui, this.address);
+          }
+        }
         const topUp = await this.topUpQuotedAsset(accept, need, onStage);
         if (topUp.preInstructions) {
           return buildPaymentOnline(this.connection, this.keypair, accept, {
@@ -290,14 +342,26 @@ export class PayClient {
     const pool = await resolvePool(this.connection, accept.asset).catch(() => null);
     if (!pool) throw new UnderfundedError(accept, null, this.address);
 
+    // Balances first. 0 wrapped + 0 underlying → throw. Never poolState or
+    // sendWrap just to discover an empty burner (measured ~4.5s per row).
+    const [wrappedNow, underlyingNow] = await Promise.all([
+      tokenBalance(this.connection, owner, accept.asset),
+      tokenBalance(this.connection, owner, pool.underlying.toBase58()),
+    ]);
+    if (skipWrapWhenEmpty(wrappedNow.raw, underlyingNow.raw, need)) {
+      throw new UnderfundedError(accept, underlyingNow.ui, this.address);
+    }
+
     for (let attempt = 0; attempt < 3; attempt++) {
-      const bal = await tokenBalance(this.connection, owner, accept.asset);
+      const bal = attempt === 0 ? wrappedNow : await tokenBalance(this.connection, owner, accept.asset);
       const short = need - bal.raw;
       if (short <= 0n) return {};
 
       const { reserves, supply } = await poolState(this.connection, pool);
       const deposit = depositForShares(short, reserves, supply);
-      const underlyingBal = await tokenBalance(this.connection, owner, pool.underlying.toBase58());
+      const underlyingBal = attempt === 0
+        ? underlyingNow
+        : await tokenBalance(this.connection, owner, pool.underlying.toBase58());
       if (underlyingBal.raw < deposit) {
         throw new UnderfundedError(accept, underlyingBal.ui, this.address);
       }